← Back to branch summary

~valavanisalex/ubuntu/precise/inkscape/fix-943984

« back to all changes in this revision

Viewing changes to inkscape-0.47pre1/src/svg/svg-affine-test.h

  • Committer: Bazaar Package Importer
  • Author(s): Bryce Harrington
  • Date: 2009-07-02 17:09:45 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20090702170945-nn6d6zswovbwju1t
Tags: 0.47~pre1-0ubuntu1
https://launchpad.net/bugs/348842
https://launchpad.net/bugs/391149
* New upstream release.
  - Don't constrain maximization on small resolution devices (pre0)
    (LP: #348842)
  - Fixes segfault on startup (pre0)
    (LP: #391149)

Show diffs side-by-side

added added

removed removed

Lines of Context:
inkscape-0.47pre1/src/svg/svg-affine-test.h
 
1
#include <cxxtest/TestSuite.h>
 
2
 
 
3
#include "svg/svg.h"
 
4
#include "streq.h"
 
5
#include <2geom/matrix.h>
 
6
#include <algorithm>
 
7
#include <glib.h>
 
8
#include <iostream>
 
9
#include <math.h>
 
10
#include <utility>
 
11
 
 
12
class SvgAffineTest : public CxxTest::TestSuite
 
13
{
 
14
private:
 
15
    struct test_t {
 
16
        char const * str;
 
17
        Geom::Matrix matrix;
 
18
    };
 
19
    struct approx_equal_pred {
 
20
        bool operator()(Geom::Matrix const &ref, Geom::Matrix const &cm) const
 
21
        {
 
22
            double maxabsdiff = 0;
 
23
            for(size_t i=0; i<6; i++) {
 
24
                maxabsdiff = std::max(std::abs(ref[i]-cm[i]), maxabsdiff);
 
25
            }
 
26
            return maxabsdiff < 1e-14;
 
27
        }
 
28
    };
 
29
    static test_t const read_matrix_tests[3];
 
30
    static test_t const read_translate_tests[3];
 
31
    static test_t const read_scale_tests[3];
 
32
    static test_t const read_rotate_tests[4];
 
33
    static test_t const read_skew_tests[3];
 
34
    static char const * const read_fail_tests[25];
 
35
    static test_t const write_matrix_tests[2];
 
36
    static test_t const write_translate_tests[3];
 
37
    static test_t const write_scale_tests[2];
 
38
    static test_t const write_rotate_tests[2];
 
39
    static test_t const write_skew_tests[3];
 
40
public:
 
41
    SvgAffineTest() {
 
42
    }
 
43
 
 
44
// createSuite and destroySuite get us per-suite setup and teardown
 
45
// without us having to worry about static initialization order, etc.
 
46
    static SvgAffineTest *createSuite() { return new SvgAffineTest(); }
 
47
    static void destroySuite( SvgAffineTest *suite ) { delete suite; }
 
48
 
 
49
    void testReadIdentity()
 
50
    {
 
51
        char const* strs[] = {
 
52
            //0,
 
53
            "",
 
54
            "matrix(1,0,0,1,0,0)",
 
55
            "translate(0,0)",
 
56
            "scale(1,1)",
 
57
            "rotate(0,0,0)",
 
58
            "skewX(0)",
 
59
            "skewY(0)"};
 
60
        size_t n = G_N_ELEMENTS(strs);
 
61
        for(size_t i=0; i<n; i++) {
 
62
            Geom::Matrix cm;
 
63
            TSM_ASSERT(strs[i] , sp_svg_transform_read(strs[i], &cm));
 
64
            TSM_ASSERT_EQUALS(strs[i] , Geom::identity() , cm);
 
65
        }
 
66
    }
 
67
 
 
68
    void testWriteIdentity()
 
69
    {
 
70
        TS_ASSERT_EQUALS(sp_svg_transform_write(Geom::identity()) , (void*)0)
 
71
    }
 
72
 
 
73
    void testReadMatrix()
 
74
    {
 
75
        for(size_t i=0; i<G_N_ELEMENTS(read_matrix_tests); i++) {
 
76
            Geom::Matrix cm;
 
77
            TSM_ASSERT(read_matrix_tests[i].str , sp_svg_transform_read(read_matrix_tests[i].str, &cm));
 
78
            TSM_ASSERT_RELATION(read_matrix_tests[i].str , approx_equal_pred , read_matrix_tests[i].matrix , cm);
 
79
        }
 
80
    }
 
81
 
 
82
    void testReadTranslate()
 
83
    {
 
84
        for(size_t i=0; i<G_N_ELEMENTS(read_translate_tests); i++) {
 
85
            Geom::Matrix cm;
 
86
            TSM_ASSERT(read_translate_tests[i].str , sp_svg_transform_read(read_translate_tests[i].str, &cm));
 
87
            TSM_ASSERT_RELATION(read_translate_tests[i].str , approx_equal_pred , read_translate_tests[i].matrix , cm);
 
88
        }
 
89
    }
 
90
 
 
91
    void testReadScale()
 
92
    {
 
93
        for(size_t i=0; i<G_N_ELEMENTS(read_scale_tests); i++) {
 
94
            Geom::Matrix cm;
 
95
            TSM_ASSERT(read_scale_tests[i].str , sp_svg_transform_read(read_scale_tests[i].str, &cm));
 
96
            TSM_ASSERT_RELATION(read_scale_tests[i].str , approx_equal_pred , read_scale_tests[i].matrix , cm);
 
97
        }
 
98
    }
 
99
 
 
100
    void testReadRotate()
 
101
    {
 
102
        for(size_t i=0; i<G_N_ELEMENTS(read_rotate_tests); i++) {
 
103
            Geom::Matrix cm;
 
104
            TSM_ASSERT(read_rotate_tests[i].str , sp_svg_transform_read(read_rotate_tests[i].str, &cm));
 
105
            TSM_ASSERT_RELATION(read_rotate_tests[i].str , approx_equal_pred , read_rotate_tests[i].matrix , cm);
 
106
        }
 
107
    }
 
108
 
 
109
    void testReadSkew()
 
110
    {
 
111
        for(size_t i=0; i<G_N_ELEMENTS(read_skew_tests); i++) {
 
112
            Geom::Matrix cm;
 
113
            TSM_ASSERT(read_skew_tests[i].str , sp_svg_transform_read(read_skew_tests[i].str, &cm));
 
114
            TSM_ASSERT_RELATION(read_skew_tests[i].str , approx_equal_pred , read_skew_tests[i].matrix , cm);
 
115
        }
 
116
    }
 
117
 
 
118
    void testWriteMatrix()
 
119
    {
 
120
        for(size_t i=0; i<G_N_ELEMENTS(write_matrix_tests); i++) {
 
121
            char * str = sp_svg_transform_write(write_matrix_tests[i].matrix);
 
122
            TS_ASSERT_RELATION(streq_rel , str , write_matrix_tests[i].str);
 
123
            g_free(str);
 
124
        }
 
125
    }
 
126
 
 
127
    void testWriteTranslate()
 
128
    {
 
129
        for(size_t i=0; i<G_N_ELEMENTS(write_translate_tests); i++) {
 
130
            char * str = sp_svg_transform_write(write_translate_tests[i].matrix);
 
131
            TS_ASSERT_RELATION(streq_rel , str , write_translate_tests[i].str);
 
132
            g_free(str);
 
133
        }
 
134
    }
 
135
 
 
136
    void testWriteScale()
 
137
    {
 
138
        for(size_t i=0; i<G_N_ELEMENTS(write_scale_tests); i++) {
 
139
            char * str = sp_svg_transform_write(write_scale_tests[i].matrix);
 
140
            TS_ASSERT_RELATION(streq_rel , str , write_scale_tests[i].str);
 
141
            g_free(str);
 
142
        }
 
143
    }
 
144
 
 
145
    void testWriteRotate()
 
146
    {
 
147
        for(size_t i=0; i<G_N_ELEMENTS(write_rotate_tests); i++) {
 
148
            char * str = sp_svg_transform_write(write_rotate_tests[i].matrix);
 
149
            TS_ASSERT_RELATION(streq_rel , str , write_rotate_tests[i].str);
 
150
            g_free(str);
 
151
        }
 
152
    }
 
153
 
 
154
    void testWriteSkew()
 
155
    {
 
156
        for(size_t i=0; i<G_N_ELEMENTS(write_skew_tests); i++) {
 
157
            char * str = sp_svg_transform_write(write_skew_tests[i].matrix);
 
158
            TS_ASSERT_RELATION(streq_rel , str , write_skew_tests[i].str);
 
159
            g_free(str);
 
160
        }
 
161
    }
 
162
 
 
163
    void testReadConcatenation()
 
164
    {
 
165
        // NOTE: According to the SVG specification (see the syntax at http://www.w3.org/TR/SVG/coords.html#TransformAttribute
 
166
        //       there should be 1 or more comma-wsp sequences between transforms... This doesn't make sense and it seems
 
167
        //       likely that instead of a + they meant a ? (zero or one comma-wsp sequences).
 
168
        char const * str = "skewY(17)skewX(9)translate(7,13)scale(2)rotate(13)translate(3,5)";
 
169
        Geom::Matrix ref(2.0199976232558053, 1.0674773585906016, -0.14125199392774669, 1.9055550612095459, 14.412730624347654, 28.499820929377454); // Precomputed using Mathematica
 
170
        Geom::Matrix cm;
 
171
        TS_ASSERT(sp_svg_transform_read(str, &cm));
 
172
        TS_ASSERT_RELATION(approx_equal_pred , ref , cm);
 
173
    }
 
174
 
 
175
    void testReadFailures()
 
176
    {
 
177
        for(size_t i=0; i<G_N_ELEMENTS(read_fail_tests); i++) {
 
178
            Geom::Matrix cm;
 
179
            TSM_ASSERT(read_fail_tests[i] , !sp_svg_transform_read(read_fail_tests[i], &cm));
 
180
        }
 
181
    }
 
182
};
 
183
 
 
184
static double const DEGREE = M_PI/180.;
 
185
 
 
186
SvgAffineTest::test_t const SvgAffineTest::read_matrix_tests[3] = {
 
187
    {"matrix(0,0,0,0,0,0)",Geom::Matrix(0,0,0,0,0,0)},
 
188
    {" matrix(1,2,3,4,5,6)",Geom::Matrix(1,2,3,4,5,6)},
 
189
    {"matrix (1 2 -3,-4,5e6,-6e-7)",Geom::Matrix(1,2,-3,-4,5e6,-6e-7)}};
 
190
SvgAffineTest::test_t const SvgAffineTest::read_translate_tests[3] = {
 
191
    {"translate(1)",Geom::Matrix(1,0,0,1,1,0)},
 
192
    {"translate(1,1)",Geom::Matrix(1,0,0,1,1,1)},
 
193
    {"translate(-1e3 .123e2)",Geom::Matrix(1,0,0,1,-1e3,.123e2)}};
 
194
SvgAffineTest::test_t const SvgAffineTest::read_scale_tests[3] = {
 
195
    {"scale(2)",Geom::Matrix(2,0,0,2,0,0)},
 
196
    {"scale(2,3)",Geom::Matrix(2,0,0,3,0,0)},
 
197
    {"scale(0.1e-2 -.475e0)",Geom::Matrix(0.1e-2,0,0,-.475e0,0,0)}};
 
198
SvgAffineTest::test_t const SvgAffineTest::read_rotate_tests[4] = {
 
199
    {"rotate(13 )",Geom::Matrix(cos(13.*DEGREE),sin(13.*DEGREE),-sin(13.*DEGREE),cos(13.*DEGREE),0,0)},
 
200
    {"rotate(-13)",Geom::Matrix(cos(-13.*DEGREE),sin(-13.*DEGREE),-sin(-13.*DEGREE),cos(-13.*DEGREE),0,0)},
 
201
    {"rotate(373)",Geom::Matrix(cos(13.*DEGREE),sin(13.*DEGREE),-sin(13.*DEGREE),cos(13.*DEGREE),0,0)},
 
202
    {"rotate(13,7,11)",Geom::Matrix(cos(13.*DEGREE),sin(13.*DEGREE),-sin(13.*DEGREE),cos(13.*DEGREE),(1-cos(13.*DEGREE))*7+sin(13.*DEGREE)*11,(1-cos(13.*DEGREE))*11-sin(13.*DEGREE)*7)}};
 
203
SvgAffineTest::test_t const SvgAffineTest::read_skew_tests[3] = {
 
204
    {"skewX( 30)",Geom::Matrix(1,0,tan(30.*DEGREE),1,0,0)},
 
205
    {"skewX(-30)",Geom::Matrix(1,0,tan(-30.*DEGREE),1,0,0)},
 
206
    {"skewY(390)",Geom::Matrix(1,tan(30.*DEGREE),0,1,0,0)}};
 
207
char const * const SvgAffineTest::read_fail_tests[25] = {
 
208
    "matrix((1,2,3,4,5,6)",
 
209
    "matrix((1,2,3,4,5,6))",
 
210
    "matrix(1,2,3,4,5,6))",
 
211
    "matrix(,1,2,3,4,5,6)",
 
212
    "matrix(1,2,3,4,5,6,)",
 
213
    "matrix(1,2,3,4,5,)",
 
214
    "matrix(1,2,3,4,5)",
 
215
    "matrix(1,2,3,4,5e6-3)", // Here numbers HAVE to be separated by a comma-wsp sequence
 
216
    "matrix(1,2,3,4,5e6.3)", // Here numbers HAVE to be separated by a comma-wsp sequence
 
217
    "translate()",
 
218
    "translate(,)",
 
219
    "translate(1,)",
 
220
    "translate(1,6,)",
 
221
    "translate(1,6,0)",
 
222
    "scale()",
 
223
    "scale(1,6,2)",
 
224
    "rotate()",
 
225
    "rotate(1,6)",
 
226
    "rotate(1,6,)",
 
227
    "rotate(1,6,3,4)",
 
228
    "skewX()",
 
229
    "skewX(-)",
 
230
    "skewX(.)",
 
231
    "skewY(,)",
 
232
    "skewY(1,2)"};
 
233
 
 
234
SvgAffineTest::test_t const SvgAffineTest::write_matrix_tests[2] = {
 
235
    {"matrix(1,2,3,4,5,6)",Geom::Matrix(1,2,3,4,5,6)},
 
236
    {"matrix(-1,2123,3,0.4,1e-8,1e20)",Geom::Matrix(-1,2.123e3,3+1e-14,0.4,1e-8,1e20)}};
 
237
SvgAffineTest::test_t const SvgAffineTest::write_translate_tests[3] = {
 
238
    {"translate(1,1)",Geom::Matrix(1,0,0,1,1,1)},
 
239
    {"translate(1)",Geom::Matrix(1,0,0,1,1,0)},
 
240
    {"translate(-1345,0.123)",Geom::Matrix(1,0,0,1,-1.345e3,.123)}};
 
241
SvgAffineTest::test_t const SvgAffineTest::write_scale_tests[2] = {
 
242
    {"scale(0)",Geom::Matrix(0,0,0,0,0,0)},
 
243
    {"scale(2,3)",Geom::Matrix(2,0,0,3,0,0)}};
 
244
SvgAffineTest::test_t const SvgAffineTest::write_rotate_tests[2] = {
 
245
    {"rotate(13)",Geom::Matrix(cos(13.*DEGREE),sin(13.*DEGREE),-sin(13.*DEGREE),cos(13.*DEGREE),0,0)},
 
246
    {"rotate(-13,7,11)",Geom::Matrix(cos(-13.*DEGREE),sin(-13.*DEGREE),-sin(-13.*DEGREE),cos(-13.*DEGREE),(1-cos(-13.*DEGREE))*7+sin(-13.*DEGREE)*11,(1-cos(-13.*DEGREE))*11-sin(-13.*DEGREE)*7)}};
 
247
SvgAffineTest::test_t const SvgAffineTest::write_skew_tests[3] = {
 
248
    {"skewX(30)",Geom::Matrix(1,0,tan(30.*DEGREE),1,0,0)},
 
249
    {"skewX(-30)",Geom::Matrix(1,0,tan(-30.*DEGREE),1,0,0)},
 
250
    {"skewY(390)",Geom::Matrix(1,tan(30.*DEGREE),0,1,0,0)}};
 
251
 
 
252
/*
 
253
  Local Variables:
 
254
  mode:c++
 
255
  c-file-style:"stroustrup"
 
256
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 
257
  indent-tabs-mode:nil
 
258
  fill-column:99
 
259
  End:
 
260
*/
 
261
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :