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/FloatPoint.h>
29#include <WebCore/FloatRect.h>
30#include <WebCore/FloatSize.h>
31#include <WebCore/IntRect.h>
32
33#if USE(CG)
34#include <CoreGraphics/CoreGraphics.h>
35#endif
36
37#if PLATFORM(WIN)
38#include <d2d1.h>
39#endif
40
41namespace TestWebKitAPI {
42
43static void testGetAndSet(WebCore::FloatRect rect)
44{
45 rect.setX(1.1f);
46 EXPECT_FLOAT_EQ(1.1f, rect.x());
47 rect.setY(2.2f);
48 EXPECT_FLOAT_EQ(2.2f, rect.y());
49 rect.setWidth(203.2f);
50 EXPECT_FLOAT_EQ(203.2f, rect.width());
51 rect.setHeight(72.9f);
52 EXPECT_FLOAT_EQ(72.9f, rect.height());
53}
54
55static void testEmptyRect(const WebCore::FloatRect& rect)
56{
57 EXPECT_FLOAT_EQ(0, rect.x());
58 EXPECT_FLOAT_EQ(0, rect.y());
59 EXPECT_FLOAT_EQ(0, rect.width());
60 EXPECT_FLOAT_EQ(0, rect.height());
61 EXPECT_FLOAT_EQ(0, rect.maxX());
62 EXPECT_FLOAT_EQ(0, rect.maxY());
63 EXPECT_TRUE(rect.isEmpty());
64 EXPECT_TRUE(rect.isZero());
65 EXPECT_FALSE(rect.isInfinite());
66}
67
68TEST(FloatRect, DefaultConstruction)
69{
70 WebCore::FloatRect test;
71
72 testEmptyRect(test);
73
74 testGetAndSet(test);
75
76 auto location = test.location();
77 EXPECT_FLOAT_EQ(0, location.x());
78 EXPECT_FLOAT_EQ(0, location.y());
79
80 auto size = test.size();
81 EXPECT_FLOAT_EQ(0, size.width());
82 EXPECT_FLOAT_EQ(0, size.height());
83}
84
85TEST(FloatRect, ValueConstruction)
86{
87 WebCore::FloatRect test(10.0f, 20.0f, 100.0f, 50.0f);
88
89 EXPECT_FLOAT_EQ(10.0f, test.x());
90 EXPECT_FLOAT_EQ(20.0f, test.y());
91 EXPECT_FLOAT_EQ(100.0f, test.width());
92 EXPECT_FLOAT_EQ(50.0f, test.height());
93 EXPECT_FLOAT_EQ(110.0f, test.maxX());
94 EXPECT_FLOAT_EQ(70.0f, test.maxY());
95 EXPECT_FALSE(test.isEmpty());
96 EXPECT_FALSE(test.isZero());
97 EXPECT_FALSE(test.isInfinite());
98
99 auto location = test.location();
100 EXPECT_FLOAT_EQ(10.0f, location.x());
101 EXPECT_FLOAT_EQ(20.0f, location.y());
102
103 auto size = test.size();
104 EXPECT_FLOAT_EQ(100.0f, size.width());
105 EXPECT_FLOAT_EQ(50.0f, size.height());
106}
107
108TEST(FloatRect, PointSizeConstruction)
109{
110 WebCore::FloatPoint location(20.0f, 30.0f);
111 WebCore::FloatSize size(100.0f, 50.0f);
112
113 WebCore::FloatRect test(location, size);
114
115 EXPECT_FLOAT_EQ(20.0f, test.x());
116 EXPECT_FLOAT_EQ(30.0f, test.y());
117 EXPECT_FLOAT_EQ(100.0f, test.width());
118 EXPECT_FLOAT_EQ(50.0f, test.height());
119 EXPECT_FLOAT_EQ(120.0f, test.maxX());
120 EXPECT_FLOAT_EQ(80.0f, test.maxY());
121 EXPECT_FALSE(test.isEmpty());
122 EXPECT_FALSE(test.isZero());
123 EXPECT_FALSE(test.isInfinite());
124
125 auto location2 = test.location();
126 EXPECT_FLOAT_EQ(20.0f, location2.x());
127 EXPECT_FLOAT_EQ(30.0f, location2.y());
128
129 auto size2 = test.size();
130 EXPECT_FLOAT_EQ(100.0f, size2.width());
131 EXPECT_FLOAT_EQ(50.0f, size2.height());
132}
133
134TEST(FloatRect, TwoPointConstruction)
135{
136 WebCore::FloatPoint point1(20.0f, 30.0f);
137 WebCore::FloatPoint point2(150.0f, 250.0f);
138
139 WebCore::FloatRect test(point1, point2);
140
141 EXPECT_FLOAT_EQ(20.0f, test.x());
142 EXPECT_FLOAT_EQ(30.0f, test.y());
143 EXPECT_FLOAT_EQ(130.0f, test.width());
144 EXPECT_FLOAT_EQ(220.0f, test.height());
145 EXPECT_FLOAT_EQ(150.0f, test.maxX());
146 EXPECT_FLOAT_EQ(250.0f, test.maxY());
147 EXPECT_FALSE(test.isEmpty());
148 EXPECT_FALSE(test.isZero());
149 EXPECT_FALSE(test.isInfinite());
150
151 auto location = test.location();
152 EXPECT_FLOAT_EQ(20.0f, location.x());
153 EXPECT_FLOAT_EQ(30.0f, location.y());
154
155 auto size = test.size();
156 EXPECT_FLOAT_EQ(130.0f, size.width());
157 EXPECT_FLOAT_EQ(220.0f, size.height());
158}
159
160TEST(FloatRect, IntRectConstruction)
161{
162 WebCore::IntRect rect(20, 30, 150, 300);
163
164 WebCore::FloatRect test(rect);
165
166 EXPECT_FLOAT_EQ(20.0f, test.x());
167 EXPECT_FLOAT_EQ(30.0f, test.y());
168 EXPECT_FLOAT_EQ(150.0f, test.width());
169 EXPECT_FLOAT_EQ(300.0f, test.height());
170 EXPECT_FLOAT_EQ(170.0f, test.maxX());
171 EXPECT_FLOAT_EQ(330.0f, test.maxY());
172 EXPECT_FALSE(test.isEmpty());
173 EXPECT_FALSE(test.isZero());
174 EXPECT_FALSE(test.isInfinite());
175
176 auto location = test.location();
177 EXPECT_FLOAT_EQ(20.0f, location.x());
178 EXPECT_FLOAT_EQ(30.0f, location.y());
179
180 auto size = test.size();
181 EXPECT_FLOAT_EQ(150.0f, size.width());
182 EXPECT_FLOAT_EQ(300.0f, size.height());
183}
184
185TEST(FloatRect, SetLocationAndSize)
186{
187 WebCore::FloatRect rect;
188
189 testEmptyRect(rect);
190
191 WebCore::FloatPoint location(10.0f, 20.0f);
192
193 rect.setLocation(location);
194
195 EXPECT_FLOAT_EQ(10.0f, rect.x());
196 EXPECT_FLOAT_EQ(20.0f, rect.y());
197 EXPECT_FLOAT_EQ(0.0f, rect.width());
198 EXPECT_FLOAT_EQ(0.0f, rect.height());
199 EXPECT_FLOAT_EQ(10.0f, rect.maxX());
200 EXPECT_FLOAT_EQ(20.0f, rect.maxY());
201 EXPECT_TRUE(rect.isEmpty());
202 EXPECT_TRUE(rect.isZero());
203 EXPECT_FALSE(rect.isInfinite());
204
205 WebCore::FloatSize size(100.0f, 200.0f);
206
207 rect.setSize(size);
208
209 EXPECT_FLOAT_EQ(10.0f, rect.x());
210 EXPECT_FLOAT_EQ(20.0f, rect.y());
211 EXPECT_FLOAT_EQ(100.0f, rect.width());
212 EXPECT_FLOAT_EQ(200.0f, rect.height());
213 EXPECT_FLOAT_EQ(110.0f, rect.maxX());
214 EXPECT_FLOAT_EQ(220.0f, rect.maxY());
215 EXPECT_FALSE(rect.isEmpty());
216 EXPECT_FALSE(rect.isZero());
217 EXPECT_FALSE(rect.isInfinite());
218}
219
220TEST(FloatRect, Center)
221{
222 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
223
224 auto center = rect.center();
225
226 EXPECT_FLOAT_EQ(70.0f, center.x());
227 EXPECT_FLOAT_EQ(130.0f, center.y());
228}
229
230TEST(FloatRect, Move)
231{
232 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
233
234 WebCore::FloatSize delta(10.0f, 20.0f);
235
236 rect.move(delta);
237
238 EXPECT_FLOAT_EQ(30.0f, rect.x());
239 EXPECT_FLOAT_EQ(50.0f, rect.y());
240
241 WebCore::FloatPoint deltaPoint(-20.0f, -40.0f);
242
243 rect.moveBy(deltaPoint);
244
245 EXPECT_FLOAT_EQ(10.0f, rect.x());
246 EXPECT_FLOAT_EQ(10.0f, rect.y());
247
248 rect.move(-10.0f, 22.0f);
249
250 EXPECT_FLOAT_EQ(0.0f, rect.x());
251 EXPECT_FLOAT_EQ(32.0f, rect.y());
252}
253
254TEST(FloatRect, Expand)
255{
256 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
257
258 WebCore::FloatSize size(100.0f, 100.0f);
259
260 rect.expand(size);
261
262 EXPECT_FLOAT_EQ(200.0f, rect.width());
263 EXPECT_FLOAT_EQ(300.0f, rect.height());
264
265 rect.expand(55.0f, 22.0f);
266
267 EXPECT_FLOAT_EQ(255.0f, rect.width());
268 EXPECT_FLOAT_EQ(322.0f, rect.height());
269
270 WebCore::FloatSize size2(-10.0f, -20.0f);
271
272 rect.expand(size2);
273
274 EXPECT_FLOAT_EQ(245.0f, rect.width());
275 EXPECT_FLOAT_EQ(302.0f, rect.height());
276
277 rect.expand(-5.0f, -2.0f);
278
279 EXPECT_FLOAT_EQ(240.0f, rect.width());
280 EXPECT_FLOAT_EQ(300.0f, rect.height());
281
282 EXPECT_FALSE(rect.isInfinite());
283}
284
285TEST(FloatRect, Contract)
286{
287 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
288
289 WebCore::FloatSize size(50.0f, 100.0f);
290
291 rect.contract(size);
292
293 EXPECT_FLOAT_EQ(50.0f, rect.width());
294 EXPECT_FLOAT_EQ(100.0f, rect.height());
295
296 rect.contract(25.0f, 22.0f);
297
298 EXPECT_FLOAT_EQ(25.0f, rect.width());
299 EXPECT_FLOAT_EQ(78.0f, rect.height());
300
301 WebCore::FloatSize size2(-10.0f, -20.0f);
302
303 rect.contract(size2);
304
305 EXPECT_FLOAT_EQ(35.0f, rect.width());
306 EXPECT_FLOAT_EQ(98.0f, rect.height());
307
308 rect.contract(-5.0f, -2.0f);
309
310 EXPECT_FLOAT_EQ(40.0f, rect.width());
311 EXPECT_FLOAT_EQ(100.0f, rect.height());
312
313 EXPECT_FALSE(rect.isInfinite());
314}
315
316TEST(FloatRect, ShiftXEdge)
317{
318 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
319
320 rect.shiftXEdgeTo(77.0f);
321
322 EXPECT_FLOAT_EQ(77.0f, rect.x());
323 EXPECT_FLOAT_EQ(120.0f, rect.maxX());
324 EXPECT_FLOAT_EQ(30.0f, rect.y());
325 EXPECT_FLOAT_EQ(230.0f, rect.maxY());
326 EXPECT_FLOAT_EQ(43.0f, rect.width());
327 EXPECT_FLOAT_EQ(200.0f, rect.height());
328
329 rect.shiftMaxXEdgeTo(200.0f);
330
331 EXPECT_FLOAT_EQ(77.0f, rect.x());
332 EXPECT_FLOAT_EQ(200.0f, rect.maxX());
333 EXPECT_FLOAT_EQ(30.0f, rect.y());
334 EXPECT_FLOAT_EQ(230.0f, rect.maxY());
335 EXPECT_FLOAT_EQ(123.0f, rect.width());
336 EXPECT_FLOAT_EQ(200.0f, rect.height());
337}
338
339TEST(FloatRect, ShiftYEdge)
340{
341 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
342
343 rect.shiftYEdgeTo(59.0f);
344
345 EXPECT_FLOAT_EQ(20.0f, rect.x());
346 EXPECT_FLOAT_EQ(120.0f, rect.maxX());
347 EXPECT_FLOAT_EQ(59.0f, rect.y());
348 EXPECT_FLOAT_EQ(230.0f, rect.maxY());
349 EXPECT_FLOAT_EQ(100.0f, rect.width());
350 EXPECT_FLOAT_EQ(171.0f, rect.height());
351
352 rect.shiftMaxYEdgeTo(270.0f);
353
354 EXPECT_FLOAT_EQ(20.0f, rect.x());
355 EXPECT_FLOAT_EQ(120.0f, rect.maxX());
356 EXPECT_FLOAT_EQ(59.0f, rect.y());
357 EXPECT_FLOAT_EQ(270.0f, rect.maxY());
358 EXPECT_FLOAT_EQ(100.0f, rect.width());
359 EXPECT_FLOAT_EQ(211.0f, rect.height());
360}
361
362TEST(FloatRect, Inflate)
363{
364 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
365
366 rect.inflateX(5.0f);
367
368 EXPECT_FLOAT_EQ(15.0f, rect.x());
369 EXPECT_FLOAT_EQ(125.0f, rect.maxX());
370
371 rect.inflateY(4.0f);
372
373 EXPECT_FLOAT_EQ(26.0f, rect.y());
374 EXPECT_FLOAT_EQ(234.0f, rect.maxY());
375
376 rect.inflate(10.0f);
377
378 EXPECT_FLOAT_EQ(5.0f, rect.x());
379 EXPECT_FLOAT_EQ(135.0f, rect.maxX());
380 EXPECT_FLOAT_EQ(16.0f, rect.y());
381 EXPECT_FLOAT_EQ(244.0f, rect.maxY());
382
383 EXPECT_FALSE(rect.isInfinite());
384}
385
386TEST(FloatRect, Corners)
387{
388 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
389
390 WebCore::FloatPoint topLeft = rect.minXMinYCorner();
391 EXPECT_FLOAT_EQ(20.0f, topLeft.x());
392 EXPECT_FLOAT_EQ(30.0f, topLeft.y());
393
394 WebCore::FloatPoint topRight = rect.maxXMinYCorner();
395 EXPECT_FLOAT_EQ(120.0f, topRight.x());
396 EXPECT_FLOAT_EQ(30.0f, topRight.y());
397
398 WebCore::FloatPoint bottomLeft = rect.minXMaxYCorner();
399 EXPECT_FLOAT_EQ(20.0f, bottomLeft.x());
400 EXPECT_FLOAT_EQ(230.0f, bottomLeft.y());
401
402 WebCore::FloatPoint bottomRight = rect.maxXMaxYCorner();
403 EXPECT_FLOAT_EQ(120.0f, bottomRight.x());
404 EXPECT_FLOAT_EQ(230.0f, bottomRight.y());
405}
406
407TEST(FloatRect, Contains)
408{
409 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
410
411 WebCore::FloatRect contained(30.0f, 40.0f, 50.0f, 100.0f);
412
413 ASSERT_TRUE(rect.contains(contained));
414
415 WebCore::FloatRect outside(120.0f, 230.0f, 50.0f, 100.0f);
416
417 ASSERT_FALSE(rect.contains(outside));
418
419 WebCore::FloatRect intersects(10.0f, 20.0f, 90.0f, 180.0f);
420
421 ASSERT_FALSE(rect.contains(intersects));
422
423 WebCore::FloatPoint pointInside(60.0f, 70.0f);
424
425 ASSERT_TRUE(rect.contains(pointInside));
426 ASSERT_TRUE(rect.contains(pointInside, WebCore::FloatRect::InsideButNotOnStroke));
427
428 WebCore::FloatPoint pointOutside(160.0f, 270.0f);
429
430 ASSERT_FALSE(rect.contains(pointOutside));
431 ASSERT_FALSE(rect.contains(pointOutside, WebCore::FloatRect::InsideButNotOnStroke));
432
433 WebCore::FloatPoint pointOnLine(20.0f, 30.0f);
434
435 ASSERT_TRUE(rect.contains(pointOnLine));
436 ASSERT_FALSE(rect.contains(pointOutside, WebCore::FloatRect::InsideButNotOnStroke));
437
438 ASSERT_TRUE(rect.contains(60.0f, 70.0f));
439 ASSERT_FALSE(rect.contains(160.0f, 270.0f));
440}
441
442TEST(FloatRect, Intersects)
443{
444 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
445
446 WebCore::FloatRect contained(30.0f, 40.0f, 50.0f, 100.0f);
447
448 ASSERT_TRUE(rect.intersects(contained));
449
450 WebCore::FloatRect outside(120.0f, 230.0f, 50.0f, 100.0f);
451
452 ASSERT_FALSE(rect.intersects(outside));
453
454 WebCore::FloatRect intersects(10.0f, 20.0f, 90.0f, 180.0f);
455
456 ASSERT_TRUE(rect.intersects(intersects));
457}
458
459static void testIntersectResult(const WebCore::FloatRect& rect)
460{
461 EXPECT_FLOAT_EQ(70.0f, rect.x());
462 EXPECT_FLOAT_EQ(120.0f, rect.maxX());
463 EXPECT_FLOAT_EQ(80.0f, rect.y());
464 EXPECT_FLOAT_EQ(230.0f, rect.maxY());
465}
466
467TEST(FloatRect, Intersect)
468{
469 WebCore::FloatRect rectA(20.0f, 30.0f, 100.0f, 200.0f);
470 WebCore::FloatRect rectB(70.0f, 80.0f, 100.0f, 200.0f);
471
472 rectA.intersect(rectB);
473
474 testIntersectResult(rectA);
475
476 WebCore::FloatRect rectC(20.0f, 30.0f, 100.0f, 200.0f);
477
478 auto intersected = WebCore::intersection(rectC, rectB);
479
480 testIntersectResult(intersected);
481}
482
483static void testUnitedRects(const WebCore::FloatRect& united)
484{
485 EXPECT_FLOAT_EQ(20.0f, united.x());
486 EXPECT_FLOAT_EQ(170.0f, united.maxX());
487 EXPECT_FLOAT_EQ(30.0f, united.y());
488 EXPECT_FLOAT_EQ(280.0f, united.maxY());
489}
490
491TEST(FloatRect, Unite)
492{
493 WebCore::FloatRect rectA(20.0f, 30.0f, 100.0f, 200.0f);
494 WebCore::FloatRect rectB(70.0f, 80.0f, 100.0f, 200.0f);
495
496 rectA.unite(rectB);
497
498 testUnitedRects(rectA);
499
500 WebCore::FloatRect rectC(20.0f, 30.0f, 100.0f, 200.0f);
501
502 auto united = WebCore::unionRect(rectC, rectB);
503
504 testUnitedRects(united);
505}
506
507TEST(FloatRect, Extend)
508{
509 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
510 WebCore::FloatPoint point(170.0f, 280.0f);
511
512 rect.extend(point);
513
514 EXPECT_FLOAT_EQ(20.0f, rect.x());
515 EXPECT_FLOAT_EQ(170.0f, rect.maxX());
516 EXPECT_FLOAT_EQ(30.0f, rect.y());
517 EXPECT_FLOAT_EQ(280.0f, rect.maxY());
518}
519
520TEST(FloatRect, Overlaps)
521{
522 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
523
524 ASSERT_FALSE(rect.overlapsXRange(0.0f, 10.0f));
525 ASSERT_TRUE(rect.overlapsXRange(10.0f, 30.0f));
526 ASSERT_TRUE(rect.overlapsXRange(40.0f, 70.0f));
527 ASSERT_TRUE(rect.overlapsXRange(110.0f, 130.0f));
528 ASSERT_FALSE(rect.overlapsXRange(140.0f, 600.0f));
529
530 ASSERT_FALSE(rect.overlapsYRange(0.0f, 10.0f));
531 ASSERT_TRUE(rect.overlapsYRange(10.0f, 40.0f));
532 ASSERT_TRUE(rect.overlapsYRange(40.0f, 70.0f));
533 ASSERT_TRUE(rect.overlapsYRange(220.0f, 250.0f));
534 ASSERT_FALSE(rect.overlapsYRange(250.0f, 600.0f));
535}
536
537TEST(FloatRect, Scale)
538{
539 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
540
541 rect.scale(2.0f);
542
543 EXPECT_FLOAT_EQ(40.0f, rect.x());
544 EXPECT_FLOAT_EQ(240.0f, rect.maxX());
545 EXPECT_FLOAT_EQ(60.0f, rect.y());
546 EXPECT_FLOAT_EQ(460.0f, rect.maxY());
547
548 rect.scale(0.5f, 2.0f);
549
550 EXPECT_FLOAT_EQ(20.0f, rect.x());
551 EXPECT_FLOAT_EQ(120.0f, rect.maxX());
552 EXPECT_FLOAT_EQ(120.0f, rect.y());
553 EXPECT_FLOAT_EQ(920.0f, rect.maxY());
554
555 rect.scale(1.0f, 0.25f);
556
557 EXPECT_FLOAT_EQ(20.0f, rect.x());
558 EXPECT_FLOAT_EQ(120.0f, rect.maxX());
559 EXPECT_FLOAT_EQ(30.0f, rect.y());
560 EXPECT_FLOAT_EQ(230.0f, rect.maxY());
561}
562
563TEST(FloatRect, Transpose)
564{
565 WebCore::FloatRect rect(20.0f, 30.0f, 100.0f, 200.0f);
566
567 auto transposed = rect.transposedRect();
568
569 EXPECT_FLOAT_EQ(30.0f, transposed.x());
570 EXPECT_FLOAT_EQ(230.0f, transposed.maxX());
571 EXPECT_FLOAT_EQ(20.0f, transposed.y());
572 EXPECT_FLOAT_EQ(120.0f, transposed.maxY());
573}
574
575TEST(FloatRect, FitToPoints)
576{
577 WebCore::FloatRect rect(10.0f, 20.0f, 30.0f, 40.0f);
578
579 WebCore::FloatPoint p0(20.0f, 30.0f);
580 WebCore::FloatPoint p1(70.0f, 130.0f);
581 WebCore::FloatPoint p2(50.0f, 20.0f);
582 WebCore::FloatPoint p3(90.0f, 190.0f);
583
584 rect.fitToPoints(p0, p1);
585
586 EXPECT_FLOAT_EQ(20.0f, rect.x());
587 EXPECT_FLOAT_EQ(70.0f, rect.maxX());
588 EXPECT_FLOAT_EQ(30.0f, rect.y());
589 EXPECT_FLOAT_EQ(130.0f, rect.maxY());
590
591 rect.fitToPoints(p0, p1, p2);
592
593 EXPECT_FLOAT_EQ(20.0f, rect.x());
594 EXPECT_FLOAT_EQ(70.0f, rect.maxX());
595 EXPECT_FLOAT_EQ(20.0f, rect.y());
596 EXPECT_FLOAT_EQ(130.0f, rect.maxY());
597
598 rect.fitToPoints(p0, p1, p2, p3);
599
600 EXPECT_FLOAT_EQ(20.0f, rect.x());
601 EXPECT_FLOAT_EQ(90.0f, rect.maxX());
602 EXPECT_FLOAT_EQ(20.0f, rect.y());
603 EXPECT_FLOAT_EQ(190.0f, rect.maxY());
604}
605
606#if USE(CG) || PLATFORM(WIN)
607static void checkCastRect(const WebCore::FloatRect& rect)
608{
609 EXPECT_FLOAT_EQ(10.0f, rect.x());
610 EXPECT_FLOAT_EQ(40.0f, rect.maxX());
611 EXPECT_FLOAT_EQ(20.0f, rect.y());
612 EXPECT_FLOAT_EQ(60.0f, rect.maxY());
613 EXPECT_FLOAT_EQ(30.0f, rect.width());
614 EXPECT_FLOAT_EQ(40.0f, rect.height());
615}
616#endif
617
618TEST(FloatRect, Casting)
619{
620 WebCore::FloatRect rect(10.0f, 20.0f, 30.0f, 40.0f);
621
622#if USE(CG)
623 CGRect cgRect = rect;
624
625 EXPECT_FLOAT_EQ(10.0f, cgRect.origin.x);
626 EXPECT_FLOAT_EQ(20.0f, cgRect.origin.y);
627 EXPECT_FLOAT_EQ(30.0f, cgRect.size.width);
628 EXPECT_FLOAT_EQ(40.0f, cgRect.size.height);
629
630 WebCore::FloatRect rectFromCGRect(cgRect);
631
632 checkCastRect(rectFromCGRect);
633#endif
634
635#if PLATFORM(WIN)
636 D2D1_RECT_F d2dRect = rect;
637
638 EXPECT_FLOAT_EQ(10.0f, d2dRect.left);
639 EXPECT_FLOAT_EQ(20.0f, d2dRect.top);
640 EXPECT_FLOAT_EQ(40.0f, d2dRect.right);
641 EXPECT_FLOAT_EQ(60.0f, d2dRect.bottom);
642
643 WebCore::FloatRect rectFromD2DRect(d2dRect);
644
645 checkCastRect(rectFromD2DRect);
646#endif
647}
648
649static void checkAdditionResult1(const WebCore::FloatRect& rect)
650{
651 EXPECT_FLOAT_EQ(10.0f, rect.x());
652 EXPECT_FLOAT_EQ(130.0f, rect.maxX());
653 EXPECT_FLOAT_EQ(20.0f, rect.y());
654 EXPECT_FLOAT_EQ(220.0f, rect.maxY());
655 EXPECT_FLOAT_EQ(120.0f, rect.width());
656 EXPECT_FLOAT_EQ(200.0f, rect.height());
657}
658
659static void checkAdditionResult2(const WebCore::FloatRect& rect)
660{
661 EXPECT_FLOAT_EQ(10.0f, rect.x());
662 EXPECT_FLOAT_EQ(250.0f, rect.maxX());
663 EXPECT_FLOAT_EQ(20.0f, rect.y());
664 EXPECT_FLOAT_EQ(240.0f, rect.maxY());
665 EXPECT_FLOAT_EQ(240.0f, rect.width());
666 EXPECT_FLOAT_EQ(220.0f, rect.height());
667}
668
669TEST(FloatRect, Addition)
670{
671 WebCore::FloatRect rect(10.0f, 20.0f, 100.0f, 100.0f);
672 WebCore::FloatRect rightSide(0.0f, 0.0f, 20.0f, 100.0f);
673 WebCore::FloatRect bottom(0.0f, 0.0f, 120.0f, 20.0f);
674
675 auto combined = rect + rightSide;
676
677 checkAdditionResult1(combined);
678
679 auto combined2 = combined + bottom;
680
681 checkAdditionResult2(combined2);
682
683 rect += rightSide;
684 rect += bottom;
685
686 checkAdditionResult2(rect);
687}
688
689TEST(FloatRect, Equality)
690{
691 WebCore::FloatRect rect(10.0f, 20.0f, 100.0f, 100.0f);
692 WebCore::FloatRect rect2(10.0f, 20.0f, 100.0f, 100.0f);
693 WebCore::FloatRect rightSide(110.0f, 20.0f, 20.0f, 100.0f);
694
695 ASSERT_TRUE(rect == rect2);
696 ASSERT_FALSE(rect != rect2);
697 ASSERT_TRUE(rect != rightSide);
698 ASSERT_FALSE(rect == rightSide);
699}
700
701TEST(FloatRect, InfiniteRect)
702{
703 WebCore::FloatRect infinite = WebCore::FloatRect::infiniteRect();
704
705 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::max() / 2, infinite.x());
706 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::max() / 2, infinite.y());
707 EXPECT_FLOAT_EQ(std::numeric_limits<float>::max(), infinite.width());
708 EXPECT_FLOAT_EQ(std::numeric_limits<float>::max(), infinite.height());
709
710 // FIXME: We have an unusual representation for our infinite rect.
711 // WebCore::Float::infiniteRect is (negative infinity)/2 for the upper left corner,
712 // while CoreGraphics and D2D use (negative infinity).
713
714#if USE(CG)
715 CGRect cgInfiniteRect = CGRectInfinite;
716
717#if PLATFORM(WIN)
718 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::max() / 2, cgInfiniteRect.origin.x);
719 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::max() / 2, cgInfiniteRect.origin.y);
720 EXPECT_FLOAT_EQ(std::numeric_limits<float>::max(), cgInfiniteRect.size.width);
721 EXPECT_FLOAT_EQ(std::numeric_limits<float>::max(), cgInfiniteRect.size.height);
722#else
723 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::max(), cgInfiniteRect.origin.x);
724 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::max(), cgInfiniteRect.origin.y);
725 EXPECT_FLOAT_EQ(std::numeric_limits<float>::max(), cgInfiniteRect.origin.x + cgInfiniteRect.size.width);
726 EXPECT_FLOAT_EQ(std::numeric_limits<float>::max(), cgInfiniteRect.origin.y + cgInfiniteRect.size.height);
727#endif
728 // ASSERT_TRUE(infinite == cgInfiniteRect);
729#endif
730
731#if PLATFORM(WIN)
732 D2D1_RECT_F d2dInfiniteRect = D2D1::InfiniteRect();
733
734 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::max(), d2dInfiniteRect.left);
735 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::max(), d2dInfiniteRect.top);
736 EXPECT_FLOAT_EQ(std::numeric_limits<float>::max(), d2dInfiniteRect.right);
737 EXPECT_FLOAT_EQ(std::numeric_limits<float>::max(), d2dInfiniteRect.bottom);
738 // ASSERT_TRUE(infinite == d2dInfiniteRect);
739#endif
740}
741
742TEST(FloatRect, EnclosingAndRounding)
743{
744 WebCore::FloatRect rect(10.0f, 20.0f, 1024.3f, 768.3f);
745
746 auto enclosed = WebCore::encloseRectToDevicePixels(rect, 1.0f);
747
748 EXPECT_FLOAT_EQ(10.0f, enclosed.x());
749 EXPECT_FLOAT_EQ(20.0f, enclosed.y());
750 EXPECT_FLOAT_EQ(1035.0f, enclosed.maxX());
751 EXPECT_FLOAT_EQ(789.0f, enclosed.maxY());
752
753 auto enclosed2 = WebCore::encloseRectToDevicePixels(rect, 2.0f);
754
755 EXPECT_FLOAT_EQ(10.0f, enclosed2.x());
756 EXPECT_FLOAT_EQ(20.0f, enclosed2.y());
757 EXPECT_FLOAT_EQ(1034.5f, enclosed2.maxX());
758 EXPECT_FLOAT_EQ(788.5f, enclosed2.maxY());
759}
760
761TEST(FloatRect, EnclosingIntRect)
762{
763 WebCore::FloatRect rect(10.0f, 20.0f, 1024.3f, 768.6f);
764
765 auto enclosed = WebCore::enclosingIntRect(rect);
766
767 EXPECT_EQ(10, enclosed.x());
768 EXPECT_EQ(20, enclosed.y());
769 EXPECT_EQ(1035, enclosed.maxX());
770 EXPECT_EQ(789, enclosed.maxY());
771
772 WebCore::FloatRect maxIntRect(INT_MIN, INT_MIN, 0, 0);
773 maxIntRect.shiftMaxXEdgeTo(INT_MAX);
774 maxIntRect.shiftMaxYEdgeTo(INT_MAX);
775
776 auto enclosed2 = WebCore::enclosingIntRect(maxIntRect);
777
778 EXPECT_EQ(INT_MIN, enclosed2.x());
779 EXPECT_EQ(INT_MIN, enclosed2.y());
780 EXPECT_EQ(INT_MAX, enclosed2.width());
781 EXPECT_EQ(INT_MAX, enclosed2.height());
782}
783
784TEST(FloatRect, RoundedIntRect)
785{
786 WebCore::FloatRect rect(10.0f, 20.0f, 1024.3f, 768.6f);
787
788 auto enclosed = WebCore::roundedIntRect(rect);
789
790 EXPECT_EQ(10, enclosed.x());
791 EXPECT_EQ(20, enclosed.y());
792 EXPECT_EQ(1034, enclosed.maxX());
793 EXPECT_EQ(789, enclosed.maxY());
794}
795
796}
797