1/*
2 * Copyright (C) 2016 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23 * THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include "config.h"
27
28#include <WebCore/AffineTransform.h>
29#include <WebCore/FloatPoint.h>
30#include <WebCore/FloatQuad.h>
31#include <WebCore/FloatRect.h>
32#include <WebCore/FloatSize.h>
33#include <WebCore/IntPoint.h>
34#include <WebCore/IntRect.h>
35#include <WebCore/IntSize.h>
36#include <WebCore/TransformationMatrix.h>
37
38#if USE(CG)
39#include <CoreGraphics/CoreGraphics.h>
40#endif
41
42#if PLATFORM(WIN)
43#include <d2d1.h>
44#endif
45
46namespace TestWebKitAPI {
47
48static void testGetAndSet(WebCore::AffineTransform& affineTransform)
49{
50 affineTransform.setA(1.1);
51 EXPECT_DOUBLE_EQ(1.1, affineTransform.a());
52 affineTransform.setB(2.2);
53 EXPECT_DOUBLE_EQ(2.2, affineTransform.b());
54 affineTransform.setC(3.3);
55 EXPECT_DOUBLE_EQ(3.3, affineTransform.c());
56 affineTransform.setD(4.4);
57 EXPECT_DOUBLE_EQ(4.4, affineTransform.d());
58 affineTransform.setE(5.5);
59 EXPECT_DOUBLE_EQ(5.5, affineTransform.e());
60 affineTransform.setF(6.6);
61 EXPECT_DOUBLE_EQ(6.6, affineTransform.f());
62}
63
64static void testIdentity(const WebCore::AffineTransform& transform)
65{
66 EXPECT_DOUBLE_EQ(1.0, transform.a());
67 EXPECT_DOUBLE_EQ(0.0, transform.b());
68 EXPECT_DOUBLE_EQ(0.0, transform.c());
69 EXPECT_DOUBLE_EQ(1.0, transform.d());
70 EXPECT_DOUBLE_EQ(0.0, transform.e());
71 EXPECT_DOUBLE_EQ(0.0, transform.f());
72}
73
74TEST(AffineTransform, DefaultConstruction)
75{
76 WebCore::AffineTransform test;
77
78 testIdentity(test);
79 testGetAndSet(test);
80
81 ASSERT_FALSE(test.isIdentity());
82}
83
84static void testValueConstruction(const WebCore::AffineTransform& transform)
85{
86 EXPECT_DOUBLE_EQ(6.0, transform.a());
87 EXPECT_DOUBLE_EQ(5.0, transform.b());
88 EXPECT_DOUBLE_EQ(4.0, transform.c());
89 EXPECT_DOUBLE_EQ(3.0, transform.d());
90 EXPECT_DOUBLE_EQ(2.0, transform.e());
91 EXPECT_DOUBLE_EQ(1.0, transform.f());
92}
93
94static void testDoubled(const WebCore::AffineTransform& transform)
95{
96 EXPECT_DOUBLE_EQ(12.0, transform.a());
97 EXPECT_DOUBLE_EQ(10.0, transform.b());
98 EXPECT_DOUBLE_EQ(8.0, transform.c());
99 EXPECT_DOUBLE_EQ(6.0, transform.d());
100 EXPECT_DOUBLE_EQ(2.0, transform.e());
101 EXPECT_DOUBLE_EQ(1.0, transform.f());
102}
103
104static void testHalved(const WebCore::AffineTransform& transform)
105{
106 EXPECT_DOUBLE_EQ(3.0, transform.a());
107 EXPECT_DOUBLE_EQ(2.5, transform.b());
108 EXPECT_DOUBLE_EQ(2.0, transform.c());
109 EXPECT_DOUBLE_EQ(1.5, transform.d());
110 EXPECT_DOUBLE_EQ(2.0, transform.e());
111 EXPECT_DOUBLE_EQ(1.0, transform.f());
112}
113
114TEST(AffineTransform, ValueConstruction)
115{
116 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
117
118 testValueConstruction(test);
119 testGetAndSet(test);
120
121 ASSERT_FALSE(test.isIdentity());
122 ASSERT_FALSE(test.preservesAxisAlignment());
123}
124
125#if USE(CG)
126TEST(AffineTransform, CGAffineTransformConstruction)
127{
128 CGAffineTransform cgTransform = CGAffineTransformMake(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
129 WebCore::AffineTransform test(cgTransform);
130
131 testValueConstruction(test);
132 testGetAndSet(test);
133
134 ASSERT_FALSE(test.isIdentity());
135}
136#endif
137
138#if PLATFORM(WIN)
139TEST(AffineTransform, D2D1MatrixConstruction)
140{
141 D2D1_MATRIX_3X2_F d2dTransform = D2D1::Matrix3x2F(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
142 WebCore::AffineTransform test(d2dTransform);
143
144 testValueConstruction(test);
145 testGetAndSet(test);
146
147 ASSERT_FALSE(test.isIdentity());
148}
149#endif
150
151TEST(AffineTransform, Identity)
152{
153 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
154
155 ASSERT_FALSE(test.isIdentity());
156 ASSERT_FALSE(test.isIdentityOrTranslation());
157 ASSERT_FALSE(test.isIdentityOrTranslationOrFlipped());
158 ASSERT_FALSE(test.preservesAxisAlignment());
159
160 test.makeIdentity();
161
162 ASSERT_TRUE(test.isIdentity());
163 ASSERT_TRUE(test.isIdentityOrTranslation());
164 ASSERT_TRUE(test.isIdentityOrTranslationOrFlipped());
165 ASSERT_TRUE(test.preservesAxisAlignment());
166
167 testIdentity(test);
168}
169
170TEST(AffineTransform, MapFloatPoint)
171{
172 WebCore::AffineTransform test;
173 WebCore::FloatPoint point(100.0f, 50.0f);
174
175 auto mappedPoint = test.mapPoint(point);
176
177 ASSERT_FLOAT_EQ(100.0f, mappedPoint.x());
178 ASSERT_FLOAT_EQ(50.0f, mappedPoint.y());
179
180 test.setD(2.0);
181
182 auto mappedPoint2 = test.mapPoint(point);
183
184 ASSERT_FLOAT_EQ(100.0f, mappedPoint2.x());
185 ASSERT_FLOAT_EQ(100.0f, mappedPoint2.y());
186
187 test.setA(0.5);
188
189 auto mappedPoint3 = test.mapPoint(point);
190
191 ASSERT_FLOAT_EQ(50.0f, mappedPoint3.x());
192 ASSERT_FLOAT_EQ(100.0f, mappedPoint3.y());
193}
194
195TEST(AffineTransform, MapIntPoint)
196{
197 WebCore::AffineTransform test;
198 WebCore::IntPoint point(100, 50);
199
200 auto mappedPoint = test.mapPoint(point);
201
202 ASSERT_EQ(100, mappedPoint.x());
203 ASSERT_EQ(50, mappedPoint.y());
204
205 test.setD(2.0);
206
207 auto mappedPoint2 = test.mapPoint(point);
208
209 ASSERT_EQ(100, mappedPoint2.x());
210 ASSERT_EQ(100, mappedPoint2.y());
211
212 test.setA(0.5);
213
214 auto mappedPoint3 = test.mapPoint(point);
215
216 ASSERT_EQ(50, mappedPoint3.x());
217 ASSERT_EQ(100, mappedPoint3.y());
218}
219
220TEST(AffineTransform, MapIntSize)
221{
222 WebCore::AffineTransform test;
223 WebCore::IntSize size(200, 300);
224
225 auto mappedSize = test.mapSize(size);
226
227 ASSERT_EQ(200, mappedSize.width());
228 ASSERT_EQ(300, mappedSize.height());
229
230 test.setD(2.0);
231
232 auto mappedSize2 = test.mapSize(size);
233
234 ASSERT_EQ(200, mappedSize2.width());
235 ASSERT_EQ(600, mappedSize2.height());
236
237 test.setA(0.5);
238
239 auto mappedSize3 = test.mapSize(size);
240
241 ASSERT_EQ(100, mappedSize3.width());
242 ASSERT_EQ(600, mappedSize3.height());
243}
244
245TEST(AffineTransform, MapFloatSize)
246{
247 WebCore::AffineTransform test;
248 WebCore::FloatSize size(200.0f, 300.0f);
249
250 auto mappedSize = test.mapSize(size);
251
252 ASSERT_EQ(200.0f, mappedSize.width());
253 ASSERT_EQ(300.0f, mappedSize.height());
254
255 test.setD(2.0);
256
257 auto mappedSize2 = test.mapSize(size);
258
259 ASSERT_EQ(200.0f, mappedSize2.width());
260 ASSERT_EQ(600.0f, mappedSize2.height());
261
262 test.setA(0.5);
263
264 auto mappedSize3 = test.mapSize(size);
265
266 ASSERT_EQ(100.0f, mappedSize3.width());
267 ASSERT_EQ(600.0f, mappedSize3.height());
268}
269
270TEST(AffineTransform, MapIntRect)
271{
272 WebCore::AffineTransform test;
273 WebCore::IntRect rect(10, 20, 200, 300);
274
275 auto mappedRect = test.mapRect(rect);
276
277 ASSERT_EQ(10, mappedRect.x());
278 ASSERT_EQ(20, mappedRect.y());
279 ASSERT_EQ(200, mappedRect.width());
280 ASSERT_EQ(300, mappedRect.height());
281
282 test.setD(2.0);
283
284 auto mappedRect2 = test.mapRect(rect);
285
286 ASSERT_EQ(10, mappedRect2.x());
287 ASSERT_EQ(40, mappedRect2.y());
288 ASSERT_EQ(200, mappedRect2.width());
289 ASSERT_EQ(600, mappedRect2.height());
290
291 test.setA(0.5);
292
293 auto mappedRect3 = test.mapRect(rect);
294
295 ASSERT_EQ(5, mappedRect3.x());
296 ASSERT_EQ(40, mappedRect3.y());
297 ASSERT_EQ(100, mappedRect3.width());
298 ASSERT_EQ(600, mappedRect3.height());
299}
300
301TEST(AffineTransform, MapFloatRect)
302{
303 WebCore::AffineTransform test;
304 WebCore::FloatRect rect(10.f, 20.0f, 200.0f, 300.0f);
305
306 auto mappedRect = test.mapRect(rect);
307
308 ASSERT_FLOAT_EQ(10.0f, mappedRect.x());
309 ASSERT_FLOAT_EQ(20.0f, mappedRect.y());
310 ASSERT_FLOAT_EQ(200.0f, mappedRect.width());
311 ASSERT_FLOAT_EQ(300.0f, mappedRect.height());
312
313 test.setD(2.0);
314
315 auto mappedRect2 = test.mapRect(rect);
316
317 ASSERT_FLOAT_EQ(10.0f, mappedRect2.x());
318 ASSERT_FLOAT_EQ(40.0f, mappedRect2.y());
319 ASSERT_FLOAT_EQ(200.0f, mappedRect2.width());
320 ASSERT_FLOAT_EQ(600.0f, mappedRect2.height());
321
322 test.setA(0.5);
323
324 auto mappedRect3 = test.mapRect(rect);
325
326 ASSERT_FLOAT_EQ(5.0f, mappedRect3.x());
327 ASSERT_FLOAT_EQ(40.0f, mappedRect3.y());
328 ASSERT_FLOAT_EQ(100.0f, mappedRect3.width());
329 ASSERT_FLOAT_EQ(600.0f, mappedRect3.height());
330}
331
332TEST(AffineTransform, MapFloatQuad)
333{
334 WebCore::FloatRect rect(100.0f, 100.0f, 100.0f, 50.0f);
335 WebCore::FloatQuad quad(rect);
336
337 ASSERT_FLOAT_EQ(100.0f, quad.p1().x());
338 ASSERT_FLOAT_EQ(100.0f, quad.p1().y());
339 ASSERT_FLOAT_EQ(200.0f, quad.p2().x());
340 ASSERT_FLOAT_EQ(100.0f, quad.p2().y());
341 ASSERT_FLOAT_EQ(200.0f, quad.p3().x());
342 ASSERT_FLOAT_EQ(150.0f, quad.p3().y());
343 ASSERT_FLOAT_EQ(100.0f, quad.p4().x());
344 ASSERT_FLOAT_EQ(150.0f, quad.p4().y());
345
346 WebCore::AffineTransform test;
347 auto mappedQuad = test.mapQuad(quad);
348
349 ASSERT_FLOAT_EQ(100.0f, mappedQuad.p1().x());
350 ASSERT_FLOAT_EQ(100.0f, mappedQuad.p1().y());
351 ASSERT_FLOAT_EQ(200.0f, mappedQuad.p2().x());
352 ASSERT_FLOAT_EQ(100.0f, mappedQuad.p2().y());
353 ASSERT_FLOAT_EQ(200.0f, mappedQuad.p3().x());
354 ASSERT_FLOAT_EQ(150.0f, mappedQuad.p3().y());
355 ASSERT_FLOAT_EQ(100.0f, mappedQuad.p4().x());
356 ASSERT_FLOAT_EQ(150.0f, mappedQuad.p4().y());
357
358 test.setD(2.0);
359
360 auto mappedQuad2 = test.mapQuad(quad);
361
362 ASSERT_FLOAT_EQ(100.0f, mappedQuad2.p1().x());
363 ASSERT_FLOAT_EQ(200.0f, mappedQuad2.p1().y());
364 ASSERT_FLOAT_EQ(200.0f, mappedQuad2.p2().x());
365 ASSERT_FLOAT_EQ(200.0f, mappedQuad2.p2().y());
366 ASSERT_FLOAT_EQ(200.0f, mappedQuad2.p3().x());
367 ASSERT_FLOAT_EQ(300.0f, mappedQuad2.p3().y());
368 ASSERT_FLOAT_EQ(100.0f, mappedQuad2.p4().x());
369 ASSERT_FLOAT_EQ(300.0f, mappedQuad2.p4().y());
370
371 test.setA(0.5);
372
373 auto mappedQuad3 = test.mapQuad(quad);
374
375 ASSERT_FLOAT_EQ(50.0f, mappedQuad3.p1().x());
376 ASSERT_FLOAT_EQ(200.0f, mappedQuad3.p1().y());
377 ASSERT_FLOAT_EQ(100.0f, mappedQuad3.p2().x());
378 ASSERT_FLOAT_EQ(200.0f, mappedQuad3.p2().y());
379 ASSERT_FLOAT_EQ(100.0f, mappedQuad3.p3().x());
380 ASSERT_FLOAT_EQ(300.0f, mappedQuad3.p3().y());
381 ASSERT_FLOAT_EQ(50.0f, mappedQuad3.p4().x());
382 ASSERT_FLOAT_EQ(300.0f, mappedQuad3.p4().y());
383}
384
385TEST(AffineTransform, Multiply)
386{
387 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
388 WebCore::AffineTransform identity;
389
390 testValueConstruction(test);
391
392 test.multiply(identity);
393
394 testValueConstruction(test);
395
396 WebCore::AffineTransform doubler(2.0, 0.0, 0.0, 2.0, 0.0, 0.0);
397
398 test.multiply(doubler);
399
400 testDoubled(test);
401
402 WebCore::AffineTransform halver(0.5, 0.0, 0.0, 0.5, 0.0, 0.0);
403
404 test.multiply(halver);
405
406 testValueConstruction(test);
407
408 test.multiply(halver);
409
410 testHalved(test);
411}
412
413TEST(AffineTransform, Scale)
414{
415 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
416
417 testValueConstruction(test);
418
419 test.scale(1.0);
420
421 testValueConstruction(test);
422
423 test.scale(2.0);
424
425 testDoubled(test);
426
427 test.scale(0.5);
428
429 testValueConstruction(test);
430
431 test.scale(0.5);
432
433 testHalved(test);
434}
435
436TEST(AffineTransform, ScaleUniformNonUniform)
437{
438 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
439
440 testValueConstruction(test);
441
442 test.scaleNonUniform(1.0, 1.0);
443
444 testValueConstruction(test);
445
446 test.scaleNonUniform(2.0, 2.0);
447
448 testDoubled(test);
449
450 test.scaleNonUniform(0.5, 0.5);
451
452 testValueConstruction(test);
453
454 test.scaleNonUniform(0.5, 0.5);
455
456 testHalved(test);
457}
458
459TEST(AffineTransform, ScaleNonUniform)
460{
461 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
462
463 testValueConstruction(test);
464
465 test.scaleNonUniform(1.0, 2.0);
466
467 EXPECT_DOUBLE_EQ(6.0, test.a());
468 EXPECT_DOUBLE_EQ(5.0, test.b());
469 EXPECT_DOUBLE_EQ(8.0, test.c());
470 EXPECT_DOUBLE_EQ(6.0, test.d());
471 EXPECT_DOUBLE_EQ(2.0, test.e());
472 EXPECT_DOUBLE_EQ(1.0, test.f());
473
474 test.scaleNonUniform(1.0, 0.5);
475
476 testValueConstruction(test);
477
478 test.scaleNonUniform(2.0, 1.0);
479
480 EXPECT_DOUBLE_EQ(12.0, test.a());
481 EXPECT_DOUBLE_EQ(10.0, test.b());
482 EXPECT_DOUBLE_EQ(4.0, test.c());
483 EXPECT_DOUBLE_EQ(3.0, test.d());
484 EXPECT_DOUBLE_EQ(2.0, test.e());
485 EXPECT_DOUBLE_EQ(1.0, test.f());
486
487 test.scaleNonUniform(0.5, 1.0);
488
489 testValueConstruction(test);
490
491 test.scaleNonUniform(0.5, 2.0);
492
493 EXPECT_DOUBLE_EQ(3.0, test.a());
494 EXPECT_DOUBLE_EQ(2.5, test.b());
495 EXPECT_DOUBLE_EQ(8.0, test.c());
496 EXPECT_DOUBLE_EQ(6.0, test.d());
497 EXPECT_DOUBLE_EQ(2.0, test.e());
498 EXPECT_DOUBLE_EQ(1.0, test.f());
499}
500
501TEST(AffineTransform, ScaleFloatSize)
502{
503 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
504
505 testValueConstruction(test);
506
507 WebCore::FloatSize first(1.0f, 2.0f);
508
509 test.scale(first);
510
511 EXPECT_DOUBLE_EQ(6.0, test.a());
512 EXPECT_DOUBLE_EQ(5.0, test.b());
513 EXPECT_DOUBLE_EQ(8.0, test.c());
514 EXPECT_DOUBLE_EQ(6.0, test.d());
515 EXPECT_DOUBLE_EQ(2.0, test.e());
516 EXPECT_DOUBLE_EQ(1.0, test.f());
517
518 WebCore::FloatSize second(1.0f, 0.5f);
519
520 test.scale(second);
521
522 testValueConstruction(test);
523
524 WebCore::FloatSize third(2.0f, 1.0f);
525
526 test.scale(third);
527
528 EXPECT_DOUBLE_EQ(12.0, test.a());
529 EXPECT_DOUBLE_EQ(10.0, test.b());
530 EXPECT_DOUBLE_EQ(4.0, test.c());
531 EXPECT_DOUBLE_EQ(3.0, test.d());
532 EXPECT_DOUBLE_EQ(2.0, test.e());
533 EXPECT_DOUBLE_EQ(1.0, test.f());
534
535 WebCore::FloatSize fourth(0.5f, 1.0f);
536
537 test.scale(fourth);
538
539 testValueConstruction(test);
540
541 WebCore::FloatSize fifth(0.5f, 2.0f);
542
543 test.scale(fifth);
544
545 EXPECT_DOUBLE_EQ(3.0, test.a());
546 EXPECT_DOUBLE_EQ(2.5, test.b());
547 EXPECT_DOUBLE_EQ(8.0, test.c());
548 EXPECT_DOUBLE_EQ(6.0, test.d());
549 EXPECT_DOUBLE_EQ(2.0, test.e());
550 EXPECT_DOUBLE_EQ(1.0, test.f());
551}
552
553TEST(AffineTransform, Rotate)
554{
555 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
556
557 test.rotate(360.0);
558
559 testValueConstruction(test);
560
561 test.rotate(180.0);
562
563 static double epsilon = 0.0001;
564
565 EXPECT_NEAR(-6.0, test.a(), epsilon);
566 EXPECT_NEAR(-5.0, test.b(), epsilon);
567 EXPECT_NEAR(-4.0, test.c(), epsilon);
568 EXPECT_NEAR(-3.0, test.d(), epsilon);
569 EXPECT_DOUBLE_EQ(2.0, test.e());
570 EXPECT_DOUBLE_EQ(1.0, test.f());
571
572 test.rotate(-180.0);
573
574 testValueConstruction(test);
575
576 test.rotate(90.0);
577
578 EXPECT_NEAR(4.0, test.a(), epsilon);
579 EXPECT_NEAR(3.0, test.b(), epsilon);
580 EXPECT_NEAR(-6.0, test.c(), epsilon);
581 EXPECT_NEAR(-5.0, test.d(), epsilon);
582 EXPECT_DOUBLE_EQ(2.0, test.e());
583 EXPECT_DOUBLE_EQ(1.0, test.f());
584
585 test.rotate(-90.0);
586
587 testValueConstruction(test);
588}
589
590TEST(AffineTransform, TranslateXY)
591{
592 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
593
594 test.translate(0.0, 0.0);
595
596 testValueConstruction(test);
597
598 test.translate(5.0, 0.0);
599
600 EXPECT_DOUBLE_EQ(6.0, test.a());
601 EXPECT_DOUBLE_EQ(5.0, test.b());
602 EXPECT_DOUBLE_EQ(4.0, test.c());
603 EXPECT_DOUBLE_EQ(3.0, test.d());
604 EXPECT_DOUBLE_EQ(32.0, test.e());
605 EXPECT_DOUBLE_EQ(26.0, test.f());
606
607 test.translate(0.0, -1.2);
608
609 EXPECT_DOUBLE_EQ(6.0, test.a());
610 EXPECT_DOUBLE_EQ(5.0, test.b());
611 EXPECT_DOUBLE_EQ(4.0, test.c());
612 EXPECT_DOUBLE_EQ(3.0, test.d());
613 EXPECT_DOUBLE_EQ(27.2, test.e());
614 EXPECT_DOUBLE_EQ(22.4, test.f());
615}
616
617TEST(AffineTransform, TranslateFloatPoint)
618{
619 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
620
621 WebCore::FloatPoint none;
622 test.translate(none);
623
624 testValueConstruction(test);
625
626 WebCore::FloatPoint first(5.0f, 0.0f);
627
628 test.translate(first);
629
630 EXPECT_DOUBLE_EQ(6.0, test.a());
631 EXPECT_DOUBLE_EQ(5.0, test.b());
632 EXPECT_DOUBLE_EQ(4.0, test.c());
633 EXPECT_DOUBLE_EQ(3.0, test.d());
634 EXPECT_DOUBLE_EQ(32.0, test.e());
635 EXPECT_DOUBLE_EQ(26.0, test.f());
636
637 WebCore::FloatPoint second(0.0f, -1.2f);
638
639 test.translate(second);
640
641 static double epsilon = 0.0001;
642
643 EXPECT_DOUBLE_EQ(6.0, test.a());
644 EXPECT_DOUBLE_EQ(5.0, test.b());
645 EXPECT_DOUBLE_EQ(4.0, test.c());
646 EXPECT_DOUBLE_EQ(3.0, test.d());
647 EXPECT_NEAR(27.2, test.e(), epsilon);
648 EXPECT_NEAR(22.4, test.f(), epsilon);
649
650 WebCore::AffineTransform test2;
651
652 ASSERT_TRUE(test2.isIdentity());
653 ASSERT_TRUE(test2.isIdentityOrTranslation());
654 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
655
656 test2.translate(second);
657
658 ASSERT_FALSE(test2.isIdentity());
659 ASSERT_TRUE(test2.isIdentityOrTranslation());
660 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
661}
662
663TEST(AffineTransform, Shear)
664{
665 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
666
667 test.shear(0.0, 0.0);
668
669 testValueConstruction(test);
670
671 test.shear(2.0, 2.0);
672
673 EXPECT_DOUBLE_EQ(14.0, test.a());
674 EXPECT_DOUBLE_EQ(11.0, test.b());
675 EXPECT_DOUBLE_EQ(16.0, test.c());
676 EXPECT_DOUBLE_EQ(13.0, test.d());
677 EXPECT_DOUBLE_EQ(2.0, test.e());
678 EXPECT_DOUBLE_EQ(1.0, test.f());
679
680 test.shear(-1.0, 2.0);
681
682 EXPECT_DOUBLE_EQ(46.0, test.a());
683 EXPECT_DOUBLE_EQ(37.0, test.b());
684 EXPECT_DOUBLE_EQ(2.0, test.c());
685 EXPECT_DOUBLE_EQ(2.0, test.d());
686 EXPECT_DOUBLE_EQ(2.0, test.e());
687 EXPECT_DOUBLE_EQ(1.0, test.f());
688}
689
690TEST(AffineTransform, FlipX)
691{
692 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
693
694 testValueConstruction(test);
695
696 test.flipX();
697
698 EXPECT_DOUBLE_EQ(-6.0, test.a());
699 EXPECT_DOUBLE_EQ(-5.0, test.b());
700 EXPECT_DOUBLE_EQ(4.0, test.c());
701 EXPECT_DOUBLE_EQ(3.0, test.d());
702 EXPECT_DOUBLE_EQ(2.0, test.e());
703 EXPECT_DOUBLE_EQ(1.0, test.f());
704
705 test.flipX();
706
707 testValueConstruction(test);
708
709 WebCore::AffineTransform test2;
710
711 testIdentity(test2);
712
713 ASSERT_TRUE(test2.isIdentity());
714 ASSERT_TRUE(test2.isIdentityOrTranslation());
715 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
716
717 test2.flipX();
718
719 EXPECT_DOUBLE_EQ(-1.0, test2.a());
720 EXPECT_DOUBLE_EQ(0.0, test2.b());
721 EXPECT_DOUBLE_EQ(0.0, test2.c());
722 EXPECT_DOUBLE_EQ(1.0, test2.d());
723 EXPECT_DOUBLE_EQ(0.0, test2.e());
724 EXPECT_DOUBLE_EQ(0.0, test2.f());
725
726 ASSERT_FALSE(test2.isIdentity());
727 ASSERT_FALSE(test2.isIdentityOrTranslation());
728 // 'Flipped' just means in the Y direction
729 ASSERT_FALSE(test2.isIdentityOrTranslationOrFlipped());
730
731 test2.flipX();
732
733 ASSERT_TRUE(test2.isIdentity());
734 ASSERT_TRUE(test2.isIdentityOrTranslation());
735 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
736}
737
738TEST(AffineTransform, FlipY)
739{
740 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
741
742 testValueConstruction(test);
743
744 test.flipY();
745
746 EXPECT_DOUBLE_EQ(6.0, test.a());
747 EXPECT_DOUBLE_EQ(5.0, test.b());
748 EXPECT_DOUBLE_EQ(-4.0, test.c());
749 EXPECT_DOUBLE_EQ(-3.0, test.d());
750 EXPECT_DOUBLE_EQ(2.0, test.e());
751 EXPECT_DOUBLE_EQ(1.0, test.f());
752
753 test.flipY();
754
755 testValueConstruction(test);
756
757 WebCore::AffineTransform test2;
758
759 testIdentity(test2);
760
761 ASSERT_TRUE(test2.isIdentity());
762 ASSERT_TRUE(test2.isIdentityOrTranslation());
763 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
764
765 test2.flipY();
766
767 EXPECT_DOUBLE_EQ(1.0, test2.a());
768 EXPECT_DOUBLE_EQ(0.0, test2.b());
769 EXPECT_DOUBLE_EQ(0.0, test2.c());
770 EXPECT_DOUBLE_EQ(-1.0, test2.d());
771 EXPECT_DOUBLE_EQ(0.0, test2.e());
772 EXPECT_DOUBLE_EQ(0.0, test2.f());
773
774 ASSERT_FALSE(test2.isIdentity());
775 ASSERT_FALSE(test2.isIdentityOrTranslation());
776 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
777
778 test2.flipY();
779
780 ASSERT_TRUE(test2.isIdentity());
781 ASSERT_TRUE(test2.isIdentityOrTranslation());
782 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
783}
784
785TEST(AffineTransform, FlipXandFlipY)
786{
787 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
788
789 testValueConstruction(test);
790
791 test.flipX();
792
793 EXPECT_DOUBLE_EQ(-6.0, test.a());
794 EXPECT_DOUBLE_EQ(-5.0, test.b());
795 EXPECT_DOUBLE_EQ(4.0, test.c());
796 EXPECT_DOUBLE_EQ(3.0, test.d());
797 EXPECT_DOUBLE_EQ(2.0, test.e());
798 EXPECT_DOUBLE_EQ(1.0, test.f());
799
800 test.flipY();
801
802 EXPECT_DOUBLE_EQ(-6.0, test.a());
803 EXPECT_DOUBLE_EQ(-5.0, test.b());
804 EXPECT_DOUBLE_EQ(-4.0, test.c());
805 EXPECT_DOUBLE_EQ(-3.0, test.d());
806 EXPECT_DOUBLE_EQ(2.0, test.e());
807 EXPECT_DOUBLE_EQ(1.0, test.f());
808
809 test.flipX();
810
811 EXPECT_DOUBLE_EQ(6.0, test.a());
812 EXPECT_DOUBLE_EQ(5.0, test.b());
813 EXPECT_DOUBLE_EQ(-4.0, test.c());
814 EXPECT_DOUBLE_EQ(-3.0, test.d());
815 EXPECT_DOUBLE_EQ(2.0, test.e());
816 EXPECT_DOUBLE_EQ(1.0, test.f());
817
818 test.flipY();
819
820 testValueConstruction(test);
821
822 WebCore::AffineTransform test2;
823
824 ASSERT_TRUE(test2.isIdentity());
825 ASSERT_TRUE(test2.isIdentityOrTranslation());
826 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
827
828 test2.flipX();
829
830 ASSERT_FALSE(test2.isIdentity());
831 ASSERT_FALSE(test2.isIdentityOrTranslation());
832 ASSERT_FALSE(test2.isIdentityOrTranslationOrFlipped());
833
834 test2.flipY();
835
836 ASSERT_FALSE(test2.isIdentity());
837 ASSERT_FALSE(test2.isIdentityOrTranslation());
838 // False here because X is also flipped.
839 ASSERT_FALSE(test2.isIdentityOrTranslationOrFlipped());
840
841 test2.flipX();
842
843 ASSERT_FALSE(test2.isIdentity());
844 ASSERT_FALSE(test2.isIdentityOrTranslation());
845 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
846
847 test2.flipY();
848
849 ASSERT_TRUE(test2.isIdentity());
850 ASSERT_TRUE(test2.isIdentityOrTranslation());
851 ASSERT_TRUE(test2.isIdentityOrTranslationOrFlipped());
852}
853
854TEST(AffineTransform, Skew)
855{
856 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
857
858 testValueConstruction(test);
859
860 test.skew(360.0, 360.0);
861
862 testValueConstruction(test);
863
864 test.skew(0.0, 0.0);
865
866 testValueConstruction(test);
867
868 test.skew(180.0, 180.0);
869
870 static double epsilon = 0.0001;
871
872 EXPECT_DOUBLE_EQ(6.0, test.a());
873 EXPECT_DOUBLE_EQ(5.0, test.b());
874 EXPECT_NEAR(4.0, test.c(), epsilon);
875 EXPECT_DOUBLE_EQ(3.0, test.d());
876 EXPECT_DOUBLE_EQ(2.0, test.e());
877 EXPECT_DOUBLE_EQ(1.0, test.f());
878
879 test.skew(-180.0, -180.0);
880
881 testValueConstruction(test);
882}
883
884TEST(AffineTransform, XandYScale)
885{
886 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
887
888 EXPECT_NEAR(7.8102, test.xScale(), 0.0001);
889 EXPECT_NEAR(5.0, test.yScale(), 0.0001);
890}
891
892TEST(AffineTransform, Equality)
893{
894 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
895 WebCore::AffineTransform test2;
896
897 ASSERT_FALSE(test == test2);
898 ASSERT_TRUE(test != test2);
899
900 test.makeIdentity();
901
902 ASSERT_TRUE(test == test2);
903 ASSERT_FALSE(test != test2);
904}
905
906TEST(AffineTransform, Inverse)
907{
908 WebCore::AffineTransform test;
909
910 auto inverse = test.inverse();
911
912 ASSERT(inverse);
913
914 EXPECT_DOUBLE_EQ(1.0, inverse->a());
915 EXPECT_DOUBLE_EQ(0.0, inverse->b());
916 EXPECT_DOUBLE_EQ(0.0, inverse->c());
917 EXPECT_DOUBLE_EQ(1.0, inverse->d());
918 EXPECT_DOUBLE_EQ(0.0, inverse->e());
919 EXPECT_DOUBLE_EQ(0.0, inverse->f());
920
921 auto test2 = test * inverse.value();
922
923 testIdentity(test2);
924}
925
926TEST(AffineTransform, Blend)
927{
928 WebCore::AffineTransform test;
929
930 WebCore::AffineTransform test2;
931 test2.scale(2.0);
932
933 test.blend(test2, 50);
934
935 EXPECT_DOUBLE_EQ(-48.0, test.a());
936 EXPECT_DOUBLE_EQ(0.0, test.b());
937 EXPECT_DOUBLE_EQ(0.0, test.c());
938 EXPECT_DOUBLE_EQ(-48.0, test.d());
939 EXPECT_DOUBLE_EQ(0.0, test.e());
940 EXPECT_DOUBLE_EQ(0.0, test.f());
941}
942
943TEST(AffineTransform, Translation)
944{
945 auto test = WebCore::AffineTransform::translation(-5.0, -7.0);
946 EXPECT_DOUBLE_EQ(1.0, test.a());
947 EXPECT_DOUBLE_EQ(0.0, test.b());
948 EXPECT_DOUBLE_EQ(0.0, test.c());
949 EXPECT_DOUBLE_EQ(1.0, test.d());
950 EXPECT_DOUBLE_EQ(-5.0, test.e());
951 EXPECT_DOUBLE_EQ(-7.0, test.f());
952}
953
954TEST(AffineTransform, ToTransformationMatrix)
955{
956 WebCore::AffineTransform transform;
957 WebCore::TransformationMatrix matrix = transform.toTransformationMatrix();
958
959 EXPECT_DOUBLE_EQ(1.0, matrix.m11());
960 EXPECT_DOUBLE_EQ(0.0, matrix.m12());
961 EXPECT_DOUBLE_EQ(0.0, matrix.m13());
962 EXPECT_DOUBLE_EQ(0.0, matrix.m14());
963 EXPECT_DOUBLE_EQ(0.0, matrix.m21());
964 EXPECT_DOUBLE_EQ(1.0, matrix.m22());
965 EXPECT_DOUBLE_EQ(0.0, matrix.m23());
966 EXPECT_DOUBLE_EQ(0.0, matrix.m24());
967 EXPECT_DOUBLE_EQ(0.0, matrix.m31());
968 EXPECT_DOUBLE_EQ(0.0, matrix.m32());
969 EXPECT_DOUBLE_EQ(1.0, matrix.m33());
970 EXPECT_DOUBLE_EQ(0.0, matrix.m34());
971}
972
973TEST(AffineTransform, MakeMapBetweenRects)
974{
975 WebCore::AffineTransform transform;
976
977 WebCore::FloatRect fromRect(10.0f, 10.0f, 100.0f, 100.0f);
978 WebCore::FloatRect toRect(70.0f, 70.0f, 200.0f, 50.0f);
979
980 auto mapBetween = WebCore::makeMapBetweenRects(fromRect, toRect);
981
982 EXPECT_DOUBLE_EQ(2.0, mapBetween.a());
983 EXPECT_DOUBLE_EQ(0.0, mapBetween.b());
984 EXPECT_DOUBLE_EQ(0.0, mapBetween.c());
985 EXPECT_DOUBLE_EQ(0.5, mapBetween.d());
986 EXPECT_DOUBLE_EQ(60.0, mapBetween.e());
987 EXPECT_DOUBLE_EQ(60.0, mapBetween.f());
988}
989
990#if USE(CG)
991TEST(AffineTransform, CoreGraphicsCasting)
992{
993 WebCore::AffineTransform test(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
994
995 CGAffineTransform test2 = CGAffineTransformMake(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
996
997 ASSERT_TRUE(CGAffineTransformEqualToTransform(test, test2));
998
999 WebCore::AffineTransform test3;
1000
1001 ASSERT_FALSE(CGAffineTransformEqualToTransform(test, test3));
1002}
1003#endif
1004
1005#if PLATFORM(WIN)
1006TEST(AffineTransform, Direct2DCasting)
1007{
1008 WebCore::AffineTransform transform(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
1009
1010 D2D1_MATRIX_3X2_F test = transform;
1011 D2D1_MATRIX_3X2_F test2 = D2D1::Matrix3x2F(6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
1012
1013 static const double epsilon = 0.0000001;
1014
1015 EXPECT_NEAR(test._11, test2._11, epsilon);
1016 EXPECT_NEAR(test._12, test2._12, epsilon);
1017 EXPECT_NEAR(test._21, test2._21, epsilon);
1018 EXPECT_NEAR(test._22, test2._22, epsilon);
1019 EXPECT_NEAR(test._31, test2._31, epsilon);
1020 EXPECT_NEAR(test._32, test2._32, epsilon);
1021}
1022#endif
1023
1024}
1025