Difference between revisions of "TestSuite-blueprint"

From Inkscape Wiki
Jump to navigation Jump to search
(New page: Inkscape has had a number of unit tests for quite some time now. This page describes a proposal (by Jasper van de Gronde) for the GSoC 2008 to improve the current test suite. In short, I ...)
 
(Replaced content with "removed - outdated Category:Proposals")
Tags: Replaced Visual edit
 
(37 intermediate revisions by 3 users not shown)
Line 1: Line 1:
Inkscape has had a number of unit tests for quite some time now. This page describes a proposal (by Jasper van de Gronde) for the GSoC 2008 to improve the current test suite.
removed - outdated


In short, I will make sure these tests run on all supported platforms, write new tests to increase the unit test coverage of the codebase, create a way to perform higher-level tests and set up a system to run all these tests automatically and periodically, publishing the results on-line (in a raw form) and possibly notifying certain individuals if something goes wrong.
[[Category:Proposals]]
 
== Unit tests ==
 
=== Building on other platforms ===
 
Currently the unit tests only run on Linux. The other two major platforms that Inkscape runs on are Windows and MacOS X. MacOS X uses more or less the same build system as Linux, but Windows uses a special-purpose buildtool. I will make sure all tests run on all three platforms.
 
[TODO: Note about MacOS X]
 
I have tried building the existing unit tests on Windows and encountered the following problems:
 
* There are both CxxTest and Utest based unit tests, each requiring a different build method. The CxxTest framework being the newer, more full-featured framework.
* For Utest an executable is created per test file, as buildtool isn't built for this it either has to be modified to make this more easy, or a relatively large piece of XML has to be copied/pasted for each test file.
* CxxTest on the other hand does use a single executable, but the test files themselves are only header files and a code generator (cxxtestgen) is used to generate the necessary cpp('s). Buildtool can reasonably easily be extended to support this.
 
Fortunately those were (practically) the only problems I encountered so far, as a feasibility test I tried (and succeeded) to get all the unit tests compiling and running on Windows with just a few changes to buildtool and build.xml (see [https://bugs.launchpad.net/inkscape/+bug/208821 bug #208821]).
 
To get the CxxTests running I simply implemented two new tasks for buildtool to generate the necessary files, I will keep it this way as it is reasonably clean and works quite well. The main thing that will have to be discussed with the Inkscape community is whether or not these steps will indeed become part of the normal build process.
 
For Utest I modified the link task in buildtool to allow it to generate an executable for each file in its fileset instead of just one executable for the entire fileset. This is a bit more dubious and as a lot of the tests are already in (/converted to) the CxxTest framework I will convert the remaining Utest tests to CxxTest.
 
=== Test suite ===
 
An important part of this project is the creation of new unit tests. For starters I will write unit tests to fill some gaps and try to have more of the code that deals with converting SVG into (ultimately) a bitmap covered. This means I will at least write unit tests for:
 
* display/ (selected files)
* libnr/nr-compose (already partially done while working on a previous patch)
* svg/svg-*
* 2geom/ (at least the parts of 2geom that correspond to parts of libnr that currently have tests)
* I might create some tests for livarot, but since it is going to be replaced by cairo it will not be my first priority
 
In addition I will use coverage/profiling data (I already successfully tried to use gcov and gprof with, parts of, inkscape) and SVN logs, as well as inquiries on the developers mailinglist (for example), to try and find parts of the code which are potentially interesting to create (unit) tests for. I will publish these results, but I will probably not create unit tests for every potentially interesting piece of code this might identify (there will probably be a lot that might be interesting).
 
Apart from using coverage data to identify interesting parts of the code to test I might also use gcov to keep track of how much of the codebase is covered by (unit) tests. This kind of data could be interesting to see whether any of the existing unit tests might need some extra test cases for example. Coverage data (and/or the dependency data calculated for building inkscape) could also be used to reduce the number of tests that need to be rerun, if that would prove to be useful (so far I do not expect it to be though, the unit tests take very little time, perhaps that the higher level tests described below will take long enough to make this useful).
 
The table below shows for which files unit tests currently exist (and for what framework), the files that still have to be converted are marked in orange and yellow, an 'S' indicates that the test file exists but that it is just a stub. The tests for files marked in orange currently include the .cpp (because they also test some static functions), as CxxTest includes multiple test headers in one file this technique is probably not very desirable. If needed it would probably be sufficient to simply make sure that for each of these files a separate .cpp is generated by cxxtestgen.
 
{| border=1
! File
! CxxTest
! Utest
|-
| attributes
| Y
|
|-
| color-profile
| Y
|
|-
| dir-util
| Y
|
|-
| extract-uri
| Y
|
|-
| mod360
| Y
|
|-
| round
| Y
|
|-
| sp-gradient
| Y
|
|-
| sp-style-elem
| Y
|
|-
| syle
| Y
| Y
|-
| verbs
| Y
|
|- bgcolor="orange"
| display/bezier-utils
|
| Y
|- bgcolor="yellow"
| helper/units
|
| Y
|-
| libnr/in-svg-plane
| Y
| Y
|-
| libnr/nr-matrix
| Y
| Y
|-
| libnr/nr-point-fns
| Y
| Y
|-
| libnr/nr-rotate-fns
| Y
| Y
|-
| libnr/nr-rotate
| Y
| Y
|-
| libnr/nr-scale
| Y
| Y
|-
| libnr/nr-translate
| Y
| Y
|-
| libnr/nr-types
| Y
| Y
|-
| svg/css-ostringstream
| Y
|
|-
| svg/stringstream
| Y
|
|-
| svg/svg-color
| Y
|
|-
| util/list-container
| Y
|
|- bgcolor="orange"
| xml/quote
| S
| Y
|- bgcolor="orange"
| xml/repr-action
| S
| Y
|}
 
== High-level tests ==
 
Apart from unit tests - which focus on low-level, self-contained functionality - it is useful to test how Inkscape functions on a higher level. I will include both "rendering" tests and "verb" tests. Rendering tests simply let Inkscape render an input SVG to a bitmap and compare the result to a reference image (for an example, see [[SVG Test Suite Compliance]]). Verb tests attempt to test all sorts of UI operations, like path intersections.
 
Currently the results are evaluated completely manually. I will create a simple tool to let Inkscape render a collection of files and compare the result images to previous result images (judged by humans), initially just the reference image (which is obviously acceptable). If it finds any images for which the result differs from all judged images it will report these, the user can then judge for itself if they are acceptable. (Obviously failures to render an image at all are always reported.)
 
The procedure described above is used because the result images will hardly ever resemble the reference image exactly. This way human judgement is only needed when something actually changes. This scheme *might* be improved by allowing approximate matches based on mean squared error (or [http://pdiff.sourceforge.net/] for example) or disregarding parts of the result images (specifically certain labels in tests where the labels themselves are not important).
 
After rendering all the test images the test tool would output a list of all images along with the result of the test. This *might* be complemented by further information on how well/bad the test was passed/failed (for example, if MSE is used it might also report the actual MSE). So for example:
 
{| border=1
! Image
! Result
|-
|gradient-test.svg
|Pass
|-
|transform-test.svg
|Fail
|-
|animation-test.svg
|Crash
|}
 
Verb tests will initially work much the same as rendering tests, except that each test consists not of a single SVG file, but rather of multiple files. Each test would be accompanied by information on what verbs should be executed and what the (initial) Inkscape configuration file should be (this can affect the behaviour of some verbs).
 
For judging the result files the same procedure as with rendering tests will be followed, except that in this case it might be useful to allow for more than one result file. And it would also be useful to allow not just for bitmaps as result files. But initially the judging functionality will be pretty limited (that is, not much beyond simple file comparisons), as I feel it would exceed the scope of this project to create sophisticated comparison utilities. Where possible/desirable I will of course leverage existing utilities as much as possible.
 
== Test system ==
 
My intention is to run all the tests periodically on my own hardware for the duration of the project (for all three platforms), and I will document how I accomplished this, so that others can take over this task. SourceForge does allow some ways of being notified whenever a commit has been processed, but it is not ideal for this situation, so it might just be simpler (and just as useful) to simply poll the repository periodically (one or two times a day for example).
 
Running the tests will result in a set of output files (test results, generated output, etc.). I will make sure at least the test results will be made available on-line after each test run. This way Inkscape developers can easily see the current status of tests (as well as historical data) without having to recompile/test the code themselves (useful for tracking down when something broke for example). It would also allow them to compare the results for different platforms without having access to all platforms themselves.
 
I might also set up the system to send a notification (to the developers/testers mailinglist for example) when it finds that a test suddenly fails (while it first succeeded).
 
== Performance ==
 
All the above is just about correctness, whether or not the code performs correctly. It would however also be interesting to look at the performance of Inkscape. This is not the primary goal of this project, but it might be possible to set a few steps in this direction.
 
I regularly use gprof to profile Inkscape myself, so as a first step in this direction I might simply enable profiling when building Inkscape for testing, accumulate the profiling data from all the test runs and publish the resulting profile with the test results.
 
Another reasonably simple way to provided some performance data would be to simply look at the total execution time of each test and publish that along with the test results.

Latest revision as of 14:46, 26 May 2025

removed - outdated

Retrieved from "https://wiki.inkscape.org/wiki/index.php?title=TestSuite-blueprint&oldid=123237"