isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-23 16:40:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
0cb2ef434b
mutter/tests/conform/Makefile.am

275 lines
8.7 KiB
Makefile
Raw Normal View History

[build] Split out the custom silent rules The silent rules we use for custom targets should be moved into a separate Makefile.am that gets included from all the others.
2009-09-16 12:43:58 -04:00
include $(top_srcdir)/build/autotools/Makefile.am.silent
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
NULL =
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
noinst_PROGRAMS = test-conformance
build: Split up the test-conformance SOURCES Having different sections should make it easier to add new test units to the build.
2010-08-13 13:15:01 -04:00
# the common sources
common_sources = \
test-conform-common.h \
test-conform-common.c \
test-conform-main.c \
$(NULL)
# the unit-specific sources; please: keep all sections in alphabetical order!
units_sources =
# animation tests
units_sources += \
test-animator.c \
test-behaviours.c \
test-score.c \
test-state.c \
test-timeline.c \
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
test-timeline-interpolate.c \
test-timeline-rewind.c \
build: Split up the test-conformance SOURCES Having different sections should make it easier to add new test units to the build.
2010-08-13 13:15:01 -04:00
$(NULL)
# cogl tests
units_sources += \
test-cogl-backface-culling.c \
test-cogl-blend-strings.c \
test-cogl-depth-test.c \
test-cogl-fixed.c \
test-cogl-materials.c \
test-cogl-viewport.c \
test-cogl-multitexture.c \
test-cogl-npot-texture.c \
test-cogl-object.c \
test-cogl-offscreen.c \
test-cogl-path.c \
test-cogl-pixel-buffer.c \
test-cogl-premult.c \
test-cogl-readpixels.c \
test-cogl-sub-texture.c \
test-cogl-texture-3d.c \
test-cogl-texture-get-set-data.c \
test-cogl-texture-mipmaps.c \
test-cogl-texture-pixmap-x11.c \
test-cogl-texture-rectangle.c \
test-cogl-vertex-buffer-contiguous.c \
test-cogl-vertex-buffer-interleved.c \
test-cogl-vertex-buffer-mutability.c \
test-cogl-wrap-modes.c \
$(NULL)
# actors tests
units_sources += \
test-actor-destroy.c \
test-actor-size.c \
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
test-actor-invariants.c \
build: Split up the test-conformance SOURCES Having different sections should make it easier to add new test units to the build.
2010-08-13 13:15:01 -04:00
test-anchors.c \
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
test-binding-pool.c \
Revert "clutter.modules: Remove deps on gir-repository" This reverts commit 0ce9cf730b2a8c3b3ac4786afee0579a3795fd9e. The commit contained unrelated changes
2010-08-13 13:12:43 -04:00
test-clutter-cairo-texture.c \
build: Split up the test-conformance SOURCES Having different sections should make it easier to add new test units to the build.
2010-08-13 13:15:01 -04:00
test-clutter-rectangle.c \
test-clutter-text.c \
test-clutter-texture.c \
Revert "clutter.modules: Remove deps on gir-repository" This reverts commit 0ce9cf730b2a8c3b3ac4786afee0579a3795fd9e. The commit contained unrelated changes
2010-08-13 13:12:43 -04:00
test-group.c \
build: Split up the test-conformance SOURCES Having different sections should make it easier to add new test units to the build.
2010-08-13 13:15:01 -04:00
test-path.c \
test-paint-opacity.c \
test-pick.c \
Revert "clutter.modules: Remove deps on gir-repository" This reverts commit 0ce9cf730b2a8c3b3ac4786afee0579a3795fd9e. The commit contained unrelated changes
2010-08-13 13:12:43 -04:00
test-texture-fbo.c \
build: Split up the test-conformance SOURCES Having different sections should make it easier to add new test units to the build.
2010-08-13 13:15:01 -04:00
test-text-cache.c \
$(NULL)
# objects tests
units_sources += \
test-clutter-units.c \
test-color.c \
test-model.c \
conform: Add the beginnings of a ClutterScript test suite ClutterScript is a very complicated piece of machinery, with a parser that has custom variations on top of the basic JSON format; it could also be extended in the future, so if we don't want to introduce regressions or break existing ClutterScript definitions, we'd better have a conformance test suite.
2009-11-04 06:50:45 -05:00
test-script-parser.c \
Merge the ClutterText actor Merge branch 'text-actor' * text-actor: (108 commits) Re-align ClutterText header file [text] Fix cursor sizing Comments and whitespace fixes to ClutterText [docs] Add newly added :single-line-mode accessors Update the ignore file [tests] Add text field interactive test [text] Add single-line-mode to ClutterText [text] Fix the deletion actions [text] Use cached length when possible [tests] Add unit for the ClutterText:password-char property [docs] Update the Text section [text] Coalesce text visibility and password character Allow localizations to change the text direction Clean up the update_pango_context() function Pass the PangoContext, not the MainContext Revert the logic of the PangoContext check Remove the binding pool entry from the list Remove BindingPool::list_actions() Add ClutterActor::create_pango_context() Rename the PangoContext creation functions ...
2009-01-07 07:06:33 -05:00
$(NULL)
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
build: Split up the test-conformance SOURCES Having different sections should make it easier to add new test units to the build.
2010-08-13 13:15:01 -04:00
test_conformance_SOURCES = $(common_sources) $(units_sources)
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
# For convenience, this provides a way to easily run individual unit tests:
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
.PHONY: wrappers clean-wrappers
build: List the units inside a file This avoids trying to run test-conformance -l multiple times.
2010-09-12 21:01:50 -04:00
#UNIT_TESTS = `./test-conformance -l -m thorough | $(GREP) '^/'`
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
[build] Do not rebuild the conformance tests scripts Make the build output a little bit cleaner by not re-creating the small shell scripts that allow launching the test units separately.
2009-05-14 03:32:46 -04:00
wrappers: stamp-test-conformance
@true
tests: Generate the stub scripts using sed Instead of trying to run ./test-conformance with the -l option to generate a list of available tests it now runs sed on the test-conform-main.c file instead. Running the generated executable is a pain for cross-compiling so it would be nice to avoid it unless it's absolutely necessary. Although you could tell people who are cross compiling to just disable the conformance tests, this seems a shame because they could still be useful along with the wrappers for example if the cross compile is built to a shared network folder where the tests can be run on the actual device. The sed script is a little more ugly than it could be because it tries to avoid using the GNU extensions '\+' and '\|'. The script ends up placing restrictions on the format of the C file because the tests must all be listed on one line each. There is now a comment to explain this. Hopefully the trade off is worth it. http://bugzilla.clutter-project.org/show_bug.cgi?id=2363
2010-10-11 11:16:45 -04:00
stamp-test-conformance: Makefile $(srcdir)/test-conform-main.c
conform: Make gtester run a list of wrappers Instead of asking gtester to run ./test-conformance directly we now tell it to run a list of wrapper scripts. This results in each test being spawned in a separate process avoiding leakage of state between tests which has been a big problem with the conformance tests for quite a while now.
2010-05-06 09:53:50 -04:00
@mkdir -p wrappers
conform: Implement TEST_CONFORM_TODO() correctly The TODO() macro for adding new tests to the test suite has always meant to be implemented like the TODO block in Test::More, i.e. a test that is assumed to fail, and which warns if it unexpectedly succeeds. Since GTest lacks the expressivity of Test::More, the implementation just verifies that the tests marked as TODO actually fail, and will fail if they happen to succeed - at which point the developer will have to change the macro to SIMPLE or SKIP.
2010-10-12 12:11:52 -04:00
@sed -n \
-e 's/^ \{1,\}TEST_CONFORM_SIMPLE *(.*"\([^",]\{1,\}\)", *\([a-zA-Z0-9_]\{1,\}\).*/\/conform\1\/\2/p' \
-e 's/^ \{1,\}TEST_CONFORM_SKIP *(.*"\([^",]\{1,\}\)", *\([a-zA-Z0-9_]\{1,\}\).*/\/conform\1\/\2/p' \
-e 's/^ \{1,\}TEST_CONFORM_TODO *(.*"\([^",]\{1,\}\)", *\([a-zA-Z0-9_]\{1,\}\).*/\/conform\1\/\2/p' \
tests: Generate the stub scripts using sed Instead of trying to run ./test-conformance with the -l option to generate a list of available tests it now runs sed on the test-conform-main.c file instead. Running the generated executable is a pain for cross-compiling so it would be nice to avoid it unless it's absolutely necessary. Although you could tell people who are cross compiling to just disable the conformance tests, this seems a shame because they could still be useful along with the wrappers for example if the cross compile is built to a shared network folder where the tests can be run on the actual device. The sed script is a little more ugly than it could be because it tries to avoid using the GNU extensions '\+' and '\|'. The script ends up placing restrictions on the format of the C file because the tests must all be listed on one line each. There is now a comment to explain this. Hopefully the trade off is worth it. http://bugzilla.clutter-project.org/show_bug.cgi?id=2363
2010-10-11 11:16:45 -04:00
$(srcdir)/test-conform-main.c > unit-tests
build: Allow to run the tests from any directory I was fed up to cd into the tests/conform or tests/interactive directories to launch a specific test. Now, with the power the abs_ variants of builddir and srcdir we can run specific test from any directory. http://bugzilla.clutter-project.org/show_bug.cgi?id=2159
2010-06-06 17:47:02 -04:00
@chmod +x test-launcher.sh
build: Generate the conformance/.gitignore file Since we are generating a lot of files that we should ignore, we should generate the Git ignore file as well.
2010-08-13 13:22:12 -04:00
@( echo "/stamp-test-conformance" ; \
echo "/test-conformance" ; \
echo "*.o" ; \
build: Add XML files to the ignore blacklist
2010-09-08 12:50:38 -04:00
echo "*.xml" ; \
conform: Save the revision and date inside the test report Even if gtester-report doesn't use that information (yet), we should store the revision of Clutter that generated the report, and the date in which the test suite was ran.
2010-10-12 10:43:42 -04:00
echo "*.html" ; \
build: Generate the conformance/.gitignore file Since we are generating a lot of files that we should ignore, we should generate the Git ignore file as well.
2010-08-13 13:22:12 -04:00
echo ".gitignore" ; \
build: List the units inside a file This avoids trying to run test-conformance -l multiple times.
2010-09-12 21:01:50 -04:00
echo "unit-tests" ; \
build: Generate the conformance/.gitignore file Since we are generating a lot of files that we should ignore, we should generate the Git ignore file as well.
2010-08-13 13:22:12 -04:00
echo "/wrappers/" ) > .gitignore
build: List the units inside a file This avoids trying to run test-conformance -l multiple times.
2010-09-12 21:01:50 -04:00
@for i in `cat unit-tests`; \
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
do \
unit=`basename $$i | sed -e s/_/-/g`; \
[build] Split out the custom silent rules The silent rules we use for custom targets should be moved into a separate Makefile.am that gets included from all the others.
2009-09-16 12:43:58 -04:00
echo " GEN $$unit"; \
build: Allow to run the tests from any directory I was fed up to cd into the tests/conform or tests/interactive directories to launch a specific test. Now, with the power the abs_ variants of builddir and srcdir we can run specific test from any directory. http://bugzilla.clutter-project.org/show_bug.cgi?id=2159
2010-06-06 17:47:02 -04:00
( echo "#!/bin/sh" ; echo "$(abs_builddir)/test-launcher.sh '$$i' \"\$$@\"" ) > $$unit$(EXEEXT) ; \
build: Use the power of abs_builddir When calling test-conformance to get the list of conformance tests.
2010-09-17 06:40:10 -04:00
( echo "#!/bin/sh" ; echo "exec $(abs_builddir)/test-conformance$(EXEEXT) -p $$i \"\$$@\"" ) > wrappers/$$unit$(EXEEXT) ; \
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
chmod +x $$unit$(EXEEXT); \
conform: Make gtester run a list of wrappers Instead of asking gtester to run ./test-conformance directly we now tell it to run a list of wrapper scripts. This results in each test being spawned in a separate process avoiding leakage of state between tests which has been a big problem with the conformance tests for quite a while now.
2010-05-06 09:53:50 -04:00
chmod +x wrappers/$$unit$(EXEEXT); \
build: Generate the conformance/.gitignore file Since we are generating a lot of files that we should ignore, we should generate the Git ignore file as well.
2010-08-13 13:22:12 -04:00
echo "/$$unit$(EXEEXT)" >> .gitignore; \
[build] Do not rebuild the conformance tests scripts Make the build output a little bit cleaner by not re-creating the small shell scripts that allow launching the test units separately.
2009-05-14 03:32:46 -04:00
done \
&& echo timestamp > $(@F)
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
clean-wrappers:
build: List the units inside a file This avoids trying to run test-conformance -l multiple times.
2010-09-12 21:01:50 -04:00
@for i in `cat unit-tests`; \
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
do \
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
unit=`basename $$i | sed -e s/_/-/g`; \
[build] Split out the custom silent rules The silent rules we use for custom targets should be moved into a separate Makefile.am that gets included from all the others.
2009-09-16 12:43:58 -04:00
echo " RM $$unit"; \
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
rm -f $$unit$(EXEEXT) ; \
conform: Make gtester run a list of wrappers Instead of asking gtester to run ./test-conformance directly we now tell it to run a list of wrapper scripts. This results in each test being spawned in a separate process avoiding leakage of state between tests which has been a big problem with the conformance tests for quite a while now.
2010-05-06 09:53:50 -04:00
rm -f wrappers/$$unit$(EXEEXT) ; \
[build] Do not rebuild the conformance tests scripts Make the build output a little bit cleaner by not re-creating the small shell scripts that allow launching the test units separately.
2009-05-14 03:32:46 -04:00
done \
build: List the units inside a file This avoids trying to run test-conformance -l multiple times.
2010-09-12 21:01:50 -04:00
&& rm -f unit-tests \
[build] Do not rebuild the conformance tests scripts Make the build output a little bit cleaner by not re-creating the small shell scripts that allow launching the test units separately.
2009-05-14 03:32:46 -04:00
&& rm -f stamp-test-conformance
[tests] Create a real file for each test unit Currently, the conformance test suite creates symbolic links pointing to a wrapper script that just parses the name used to invoke it and calls the gtester with the correct path. Unfortunately, this presents two issues: - it does not really work on file systems that do not support symbolic links - it leaves behind the symbolic links, which cannot be automatically cleaning by 'make clean' Both can be solved by creating a small script that invokes the wrapper one with the test unit path. The Makefile will use test-conform to extract the unit test paths and generate a list that will be iterated over to create the executable name (using the "test-name" convention also used by the interactive tests, instead of "test_name"); the executable is then just a simple shell script that invokes the wrapper script passing the unit test path on the command line. The wrapper script will use the first argument to work correctly, so it could be simply executed like: ./test-wrapper.sh /path/to/unit_test Which is another improvement over the current implementation, where the wrapper script does not work when invoked directly.
2008-12-17 08:59:56 -05:00
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
# 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
[cogl-material] Support string based blending and layer combine descriptions Setting up layer combine functions and blend modes is very awkward to do programatically. This adds a parser for string based descriptions which are more consise and readable. E.g. a material layer combine function could now be given as: "RGBA = ADD (TEXTURE[A], PREVIOUS[RGB])" or "RGB = REPLACE (PREVIOUS)" "A = MODULATE (PREVIOUS, TEXTURE)" The simple syntax and grammar are only designed to expose standard fixed function hardware, more advanced combining must be done with shaders. This includes standalone documentation of blend strings covering the aspects that are common to blending and texture combining, and adds documentation with examples specific to the new cogl_material_set_blend() and cogl_material_layer_set_combine() functions. Note: The hope is to remove the now redundant bits of the material API before 1.0
2009-05-10 19:40:41 -04:00
tests: Allow getting data files from the tests/data directory The units under the conformance test suite should be able to use external files. Linking the files in tests/conform like the interactive tests do seems like a hack piled on top of a hack, so instead we should provide a programmatic way for a conformance test unit to get the full path of a file, regardless of where the tests/data directory is. We can use a define to get the full path of tests/data and then a function using g_build_filename() to construct the path to the file we want.
2009-11-04 06:47:09 -05:00
INCLUDES = \
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
-I$(top_srcdir)/ \
-I$(top_srcdir)/clutter \
Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
2009-07-27 21:02:02 -04:00
-I$(top_srcdir)/clutter/cogl \
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
-I$(top_builddir)/clutter \
tests: Allow getting data files from the tests/data directory The units under the conformance test suite should be able to use external files. Linking the files in tests/conform like the interactive tests do seems like a hack piled on top of a hack, so instead we should provide a programmatic way for a conformance test unit to get the full path of a file, regardless of where the tests/data directory is. We can use a define to get the full path of tests/data and then a function using g_build_filename() to construct the path to the file we want.
2009-11-04 06:47:09 -05:00
-I$(top_builddir)/clutter/cogl
test_conformance_CPPFLAGS = \
Disable single header inclusion for GLib In order to be ready for the next major version of GLib we need to disable single header inclusion by using the G_DISABLE_SINGLE_INCLUDES define in the build process.
2009-06-15 05:48:56 -04:00
-DG_DISABLE_SINGLE_INCLUDES \
build: Enable experimental COGL API in tests/conform Enable the experimental API when building the conformance test suite.
2010-02-15 06:58:55 -05:00
-DCOGL_ENABLE_EXPERIMENTAL_API \
build: Disable deprecated API in tests/conform We should not be using deprecated API in the conformance test suite.
2010-02-15 06:57:48 -05:00
-DCOGL_DISABLE_DEPRECATED \
tests: Allow getting data files from the tests/data directory The units under the conformance test suite should be able to use external files. Linking the files in tests/conform like the interactive tests do seems like a hack piled on top of a hack, so instead we should provide a programmatic way for a conformance test unit to get the full path of a file, regardless of where the tests/data directory is. We can use a define to get the full path of tests/data and then a function using g_build_filename() to construct the path to the file we want.
2009-11-04 06:47:09 -05:00
-DCLUTTER_DISABLE_DEPRECATED \
-DTESTS_DATADIR=\""$(top_srcdir)/tests/data"\"
build: Always build conformance tests with debug symbols Having the conformance test suite build without debug symbols doesn't make any sense.
2010-02-09 06:29:39 -05:00
test_conformance_CFLAGS = -g $(CLUTTER_CFLAGS) $(MAINTAINER_CFLAGS)
Split maintainer-flags from the compiler flags The maintainer compiler flags we use trigger warnings and errors in the autogenerated code that gtk-doc creates to scan the header and source files. Since we cannot control that, and we must run a distcheck with both --enable-gtk-doc and --enable-maintainer-flags turned on, we need to use less-strict compiler flags when inside the doc/reference subdirectories. The way to do this is to split the maintainer compiler flags into their own Makefile variable, called MAINTAINER_CFLAGS. The we can use $(MAINTAINER_CFLAGS) in the INCLUDES or _CFLAGS sections of each part of the source directories we wish to check with the anal retentiveness suited for maintainers.
2009-01-23 08:09:51 -05:00
build: distinguish CLUTTER_WINSYS and CLUTTER_SONAME_INFIX This adds a separate variable name "CLUTTER_SONAME_INFIX" to define the infix for the clutter library that gets linked. Currently the WINSYS corresponds to the directory we enter when building to compile the window system and input support, but it is desirable to be able to define multiple flavours that use the same WINSYS but should result in different library names. For example we are planning to combine the eglx and eglnative window systems into one "egl" winsys but we will need to preserve the current library names for the eglx and eglnative flavours.
2010-06-17 20:25:46 -04:00
test_conformance_LDADD = $(top_builddir)/clutter/libclutter-@CLUTTER_SONAME_INFIX@-@CLUTTER_API_VERSION@.la $(CLUTTER_LIBS)
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
test-conformance: Use -export-dynamic instead of -rdynamic The -rdynamic linker option is specific to ELF so it was breaking builds on systems with other object formats such as Windows and Solaris. This patch replaces that option with -export-dynamic which is a portable libtool option which should do the right thing on each platform. http://bugzilla.clutter-project.org/show_bug.cgi?id=1930
2010-06-24 12:33:43 -04:00
test_conformance_LDFLAGS = -export-dynamic
script: Allow parsing child properties The ClutterScript parser needs to be extended to parse child properties and apply them after an actor has been added to a container. In order to distinguish child properties from regular GObject properties we can use the "child::" prefix, e.g.: { "type" : "ClutterRectangle", "id" : "child-01", "child::has-focus" : true, ... } Parsing child properties can be deferred to the ClutterScriptable interface, just like regular properties.
2009-11-04 11:45:44 -05:00
conform: Make gtester run a list of wrappers Instead of asking gtester to run ./test-conformance directly we now tell it to run a list of wrapper scripts. This results in each test being spawned in a separate process avoiding leakage of state between tests which has been a big problem with the conformance tests for quite a while now.
2010-05-06 09:53:50 -04:00
test: wrappers
@$(top_srcdir)/tests/conform/run-tests.sh \
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
./test-conformance$(EXEEXT) -o test-report.xml
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
conform: Make gtester run a list of wrappers Instead of asking gtester to run ./test-conformance directly we now tell it to run a list of wrapper scripts. This results in each test being spawned in a separate process avoiding leakage of state between tests which has been a big problem with the conformance tests for quite a while now.
2010-05-06 09:53:50 -04:00
test-verbose: wrappers
@$(top_srcdir)/tests/conform/run-tests.sh \
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
./test-conformance$(EXEEXT) -o test-report.xml --verbose
Uniformly use floats in Actor properties All the underlying implementation and the public entry points have been switched to floats; the only missing bits are the Actor properties that deal with positioning and sizing. This usually means a major pain when dealing with GValues and varargs functions. While GValue will warn you when dealing with the wrong conversions, varags will simply die an horrible (and hard to debug) death via segfault. Nothing much to do here, except warn people in the release notes and hope for the best.
2009-05-31 10:15:46 -04:00
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
GTESTER = gtester
GTESTER_REPORT = gtester-report
Add a wrapper library to help testing without NPOTs. * tests/tools/Makefile.am: Optionally build the libdisable-npots.la library depending on whether libdl was detected in the configure script. A helper script is also generated to setup the LD_PRELOAD. * tests/conform/Makefile.am: There are now two versions of the test-report and full-report rules. test-report-normal is the same as before and test-report-disable-npots runs the tests with the disable-npots wrapper script. The full-report rule runs both of them and displays two separate HTML files. The test-report rule just runs the normal version as before. * configure.ac: Add a test for libdl * tests/tools/disable-npots.sh.in: New file. Template for the helper script * tests/tools/disable-npots.c: New file
2008-11-24 10:44:16 -05:00
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
# XXX: we could prevent the conformance test suite from running
# by simply defining this variable conditionally
TEST_PROGS = test-conformance
Add a wrapper library to help testing without NPOTs. * tests/tools/Makefile.am: Optionally build the libdisable-npots.la library depending on whether libdl was detected in the configure script. A helper script is also generated to setup the LD_PRELOAD. * tests/conform/Makefile.am: There are now two versions of the test-report and full-report rules. test-report-normal is the same as before and test-report-disable-npots runs the tests with the disable-npots wrapper script. The full-report rule runs both of them and displays two separate HTML files. The test-report rule just runs the normal version as before. * configure.ac: Add a test for libdl * tests/tools/disable-npots.sh.in: New file. Template for the helper script * tests/tools/disable-npots.c: New file
2008-11-24 10:44:16 -05:00
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
.PHONY: test
.PHONY: test-report perf-report full-report
.PHONY: test-report-npot perf-report-npot full-report-npot
# test-report: run tests and generate report
# perf-report: run tests with -m perf and generate report
# full-report: like test-report: with -m perf and -m slow
test-report perf-report full-report: ${TEST_PROGS}
@test -z "${TEST_PROGS}" || { \
export GTESTER_LOGDIR=`mktemp -d "$(srcdir)/.testlogs-XXXXXX"` ; \
conform: Save the revision and date inside the test report Even if gtester-report doesn't use that information (yet), we should store the revision of Clutter that generated the report, and the date in which the test suite was ran.
2010-10-12 10:43:42 -04:00
if test -d "$(top_srcdir)/.git"; then \
export REVISION="`git describe`" ; \
else \
export REVISION="$(VERSION) $(CLUTTER_RELEASE_STATUS)" ; \
fi ; \
export TIMESTAMP=`date +%Y-%m-%dT%H:%M:%S%z` ; \
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
case $@ in \
test-report) test_options="-k";; \
perf-report) test_options="-k -m=perf";; \
full-report) test_options="-k -m=perf -m=slow";; \
esac ; \
conform: Make gtester run a list of wrappers Instead of asking gtester to run ./test-conformance directly we now tell it to run a list of wrapper scripts. This results in each test being spawned in a separate process avoiding leakage of state between tests which has been a big problem with the conformance tests for quite a while now.
2010-05-06 09:53:50 -04:00
$(top_srcdir)/tests/conform/run-tests.sh \
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
./test-conformance$(EXEEXT) \
--verbose \
$$test_options \
-o `mktemp "$$GTESTER_LOGDIR/log-XXXXXX"` ; \
conform: Save the revision and date inside the test report Even if gtester-report doesn't use that information (yet), we should store the revision of Clutter that generated the report, and the date in which the test suite was ran.
2010-10-12 10:43:42 -04:00
echo '<?xml version="1.0"?>' > $@.xml ; \
echo '<report-collection>' >> $@.xml ; \
echo '<info>' >> $@.xml ; \
echo ' <package>$(PACKAGE)</package>' >> $@.xml ; \
echo ' <version>$(VERSION)</version>' >> $@.xml ; \
echo " <revision>$$REVISION</revision>" >> $@.xml ; \
echo " <date>$$TIMESTAMP</date>" >> $@.xml ; \
echo '</info>' >> $@.xml ; \
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
for lf in `ls -L "$$GTESTER_LOGDIR"/.` ; do \
sed '1,1s/^<?xml\b[^>?]*?>//' <"$$GTESTER_LOGDIR"/"$$lf" >> $@.xml ; \
done ; \
echo >> $@.xml ; \
echo '</report-collection>' >> $@.xml ; \
${GTESTER_REPORT} --version 2>/dev/null 1>&2 ; test "$$?" != 0 || ${GTESTER_REPORT} $@.xml >$@.html ; \
rm -rf "$$GTESTER_LOGDIR" ; \
}
# same as above, but with a wrapper that forcibly disables non-power of
# two textures
test-report-npot perf-report-npot full-report-npot: ${TEST_PROGS}
@test -z "${TEST_PROGS}" || { \
$(top_srcdir)/tests/tools/disable-npots.sh ; \
export GTESTER_LOGDIR=`mktemp -d "$(srcdir)/.testlogs-XXXXXX"` ; \
conform: Save the revision and date inside the test report Even if gtester-report doesn't use that information (yet), we should store the revision of Clutter that generated the report, and the date in which the test suite was ran.
2010-10-12 10:43:42 -04:00
if test -d "$(top_srcdir)/.git"; then \
export REVISION="`git describe`" ; \
else \
export REVISION="$(VERSION) $(CLUTTER_RELEASE_STATUS)" ; \
fi ; \
export TIMESTAMP=`date +%Y-%m-%dT%H:%M:%S%z` ; \
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
case $@ in \
test-report-npot) test_options="-k";; \
perf-report-npot) test_options="-k -m=perf";; \
full-report-npot) test_options="-k -m=perf -m=slow";; \
esac ; \
$(top_srcdir)/tests/conform/run-tests.sh \
./test-conformance$(EXEEXT) \
--verbose \
$$test_options \
-o `mktemp "$$GTESTER_LOGDIR/log-XXXXXX"` ; \
conform: Save the revision and date inside the test report Even if gtester-report doesn't use that information (yet), we should store the revision of Clutter that generated the report, and the date in which the test suite was ran.
2010-10-12 10:43:42 -04:00
echo '<?xml version="1.0"?>' > $@.xml ; \
echo '<report-collection>' >> $@.xml ; \
echo '<info>' >> $@.xml ; \
echo ' <package>$(PACKAGE)</package>' >> $@.xml ; \
echo ' <version>$(VERSION)</version>' >> $@.xml ; \
echo " <revision>$$REVISION</revision>" >> $@.xml ; \
echo " <date>$$TIMESTAMP</date>" >> $@.xml ; \
echo '</info>' >> $@.xml ; \
Restore the report on the conformance test suite The report generation was broken by the split of the various test units; also, we were using GTest in a way that's not really sanctioned by upstream. This commit tries to re-use the targets from GLib's Makefile rules while compensating for our own set up.
2010-07-07 09:50:24 -04:00
for lf in `ls -L "$$GTESTER_LOGDIR"/.` ; do \
sed '1,1s/^<?xml\b[^>?]*?>//' <"$$GTESTER_LOGDIR"/"$$lf" >> $@.xml ; \
done ; \
echo >> $@.xml ; \
echo '</report-collection>' >> $@.xml ; \
${GTESTER_REPORT} --version 2>/dev/null 1>&2 ; test "$$?" != 0 || ${GTESTER_REPORT} $@.xml >$@.html ; \
rm -rf "$$GTESTER_LOGDIR" ; \
}
XML_REPORTS = \
test-report.xml \
perf-report.xml \
full-report.xml \
test-report-npot.xml \
perf-report-npot.xml \
full-report-npot.xml
HTML_REPORTS = \
test-report.html \
perf-report.html \
full-report.html \
test-report-npot.html \
perf-report-npot.html \
full-report-npot.html
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 14:32:28 -05:00
build: Allow to run the tests from any directory I was fed up to cd into the tests/conform or tests/interactive directories to launch a specific test. Now, with the power the abs_ variants of builddir and srcdir we can run specific test from any directory. http://bugzilla.clutter-project.org/show_bug.cgi?id=2159
2010-06-06 17:47:02 -04:00
EXTRA_DIST = ADDING_NEW_TESTS test-launcher.sh.in run-tests.sh
build: Fix distcheck errors
2010-08-16 08:23:10 -04:00
DISTCLEANFILES = test-launcher.sh .gitignore
build: Use maintainer-clean for the ignore files removal Instead of distclean.
2010-08-15 13:42:54 -04:00
Clean up the test reports Since we override the clean-generic target in order to remove the shell scripts we create for each conformance test unit, we cannot use CLEANFILES to remove the test reports.
2009-01-23 08:29:55 -05:00
# we override the clean-generic target to clean up the wrappers so
# we cannot use CLEANFILES
clean-generic: clean-wrappers
[build] Split out the custom silent rules The silent rules we use for custom targets should be moved into a separate Makefile.am that gets included from all the others.
2009-09-16 12:43:58 -04:00
$(QUIET_RM)rm -f $(XML_REPORTS) $(HTML_REPORTS)
Reference in New Issue Copy Permalink