| Flutter macOS Embedder |

Classes | Functions | Variables
FlutterMutatorViewTest.mm File Reference
`#import "flutter/shell/platform/darwin/macos/framework/Source/FlutterMutatorView.h"`
`#include "third_party/googletest/googletest/include/gtest/gtest.h"`
`#import "flutter/shell/platform/darwin/macos/framework/Source/NSView+ClipsToBounds.h"`

Go to the source code of this file.

## Classes
category | FlutterMutatorView(Private)

## Functions
| TEST (FlutterMutatorViewTest, BasicFrameIsCorrect)
| TEST (FlutterMutatorViewTest, ClipsToBounds)
| TEST (FlutterMutatorViewTest, TransformedFrameIsCorrect)
| TEST (FlutterMutatorViewTest, FrameWithLooseClipIsCorrect)
| TEST (FlutterMutatorViewTest, FrameWithTightClipIsCorrect)
| TEST (FlutterMutatorViewTest, FrameWithTightClipAndTransformIsCorrect)
| TEST (FlutterMutatorViewTest, RoundRectClipsToSimpleRectangle)
| TEST (FlutterMutatorViewTest, ViewsSetIsFlipped)
| TEST (FlutterMutatorViewTest, RectsClipsToPathWhenRotated)
| TEST (FlutterMutatorViewTest, RoundRectClipsToPath)
| TEST (FlutterMutatorViewTest, PathClipViewsAreAddedAndRemoved)

## Variables
static constexpr float | kMaxErr = 1e-10

## Function Documentation

## ◆ TEST() [1/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | BasicFrameIsCorrect |
| ) |  |

Definition at line 61 of file FlutterMutatorViewTest.mm.

61 {
62 NSView* platformView = [[NSView alloc] init];
63 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
64
65 EXPECT_EQ(mutatorView.platformView, platformView);
66
67 std::vector<FlutterPlatformViewMutation> mutations{
68 {
69 .type = kFlutterPlatformViewMutationTypeTransformation,
70 .transformation =
71 FlutterTransformation{
72 .scaleX = 1,
73 .transX = 100,
74 .scaleY = 1,
75 .transY = 50,
76 },
77 },
78 };
79
80 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations);
81
82 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(100, 50, 30, 20)));
83 EXPECT_TRUE(CGRectEqualToRect(platformView.frame, CGRectMake(0, 0, 30, 20)));
84 EXPECT_EQ(mutatorView.pathClipViews.count, 0ull);
85 EXPECT_NE(mutatorView.platformViewContainer, nil);
86 }

References FlutterMutatorView::platformView.

## ◆ TEST() [2/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | ClipsToBounds |
| ) |  |

Definition at line 88 of file FlutterMutatorViewTest.mm.

88 {
89 NSView* platformView = [[NSView alloc] init];
90 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
91 EXPECT_TRUE(mutatorView.clipsToBounds);
92 }

## ◆ TEST() [3/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | FrameWithLooseClipIsCorrect |
| ) |  |

Definition at line 142 of file FlutterMutatorViewTest.mm.

142 {
143 NSView* platformView = [[NSView alloc] init];
144 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
145
146 EXPECT_EQ(mutatorView.platformView, platformView);
147
148 std::vector<FlutterPlatformViewMutation> mutations{
149 {
150 .type = kFlutterPlatformViewMutationTypeClipRect,
151 .clip_rect = FlutterRect{80, 40, 200, 100},
152 },
153 {
154 .type = kFlutterPlatformViewMutationTypeTransformation,
155 .transformation =
156 FlutterTransformation{
157 .scaleX = 1,
158 .transX = 100,
159 .scaleY = 1,
160 .transY = 50,
161 },
162 },
163 };
164
165 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations);
166
167 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(100, 50, 30, 20)));
168 EXPECT_TRUE(CGRectEqualToRect(platformView.frame, CGRectMake(0, 0, 30, 20)));
169 }

References FlutterMutatorView::platformView.

## ◆ TEST() [4/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | FrameWithTightClipAndTransformIsCorrect |
| ) |  |

Definition at line 206 of file FlutterMutatorViewTest.mm.

206 {
207 NSView* platformView = [[NSView alloc] init];
208 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
209 NSView* mutatorViewParent = [[NSView alloc] init];
210 mutatorViewParent.wantsLayer = YES;
211 mutatorViewParent.layer.contentsScale = 2.0;
212 [mutatorViewParent addSubview:mutatorView];
213
214 std::vector<FlutterPlatformViewMutation> mutations{
215 {
216 .type = kFlutterPlatformViewMutationTypeTransformation,
217 .transformation =
218 FlutterTransformation{
219 .scaleX = 2,
220 .scaleY = 2,
221 },
222 },
223 {
224 .type = kFlutterPlatformViewMutationTypeClipRect,
225 .clip_rect = FlutterRect{80, 40, 200, 100},
226 },
227 {
228 .type = kFlutterPlatformViewMutationTypeClipRect,
229 .clip_rect = FlutterRect{110, 55, 120, 65},
230 },
231 {
232 .type = kFlutterPlatformViewMutationTypeTransformation,
233 .transformation =
234 FlutterTransformation{
235 .scaleX = 1,
236 .transX = 100,
237 .scaleY = 1,
238 .transY = 50,
239 },
240 },
241 {
242 .type = kFlutterPlatformViewMutationTypeTransformation,
243 .transformation =
244 FlutterTransformation{
245 .scaleX = 1.5,
246 .transX = -7.5,
247 .scaleY = 1.5,
248 .transY = -5,
249 },
250 },
251 };
252
253 ApplyFlutterLayer(mutatorView, FlutterSize{30 * 2, 20 * 2}, mutations);
254
255 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(110, 55, 10, 10)));
256 EXPECT_TRUE(
257 CGRectEqualToRect(mutatorView.subviews.firstObject.frame, CGRectMake(-17.5, -10, 45, 30)));
258 EXPECT_TRUE(CGRectEqualToRect(platformView.frame, CGRectMake(0, 0, 30, 20)));
259 }

## ◆ TEST() [5/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | FrameWithTightClipIsCorrect |
| ) |  |

Definition at line 171 of file FlutterMutatorViewTest.mm.

171 {
172 NSView* platformView = [[NSView alloc] init];
173 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
174
175 EXPECT_EQ(mutatorView.platformView, platformView);
176
177 std::vector<FlutterPlatformViewMutation> mutations{
178 {
179 .type = kFlutterPlatformViewMutationTypeClipRect,
180 .clip_rect = FlutterRect{80, 40, 200, 100},
181 },
182 {
183 .type = kFlutterPlatformViewMutationTypeClipRect,
184 .clip_rect = FlutterRect{110, 55, 120, 65},
185 },
186 {
187 .type = kFlutterPlatformViewMutationTypeTransformation,
188 .transformation =
189 FlutterTransformation{
190 .scaleX = 1,
191 .transX = 100,
192 .scaleY = 1,
193 .transY = 50,
194 },
195 },
196 };
197
198 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations);
199
200 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(110, 55, 10, 10)));
201 EXPECT_TRUE(
202 CGRectEqualToRect(mutatorView.subviews.firstObject.frame, CGRectMake(-10, -5, 30, 20)));
203 EXPECT_TRUE(CGRectEqualToRect(platformView.frame, CGRectMake(0, 0, 30, 20)));
204 }

References FlutterMutatorView::platformView.

## ◆ TEST() [6/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | PathClipViewsAreAddedAndRemoved |
| ) |  |

Definition at line 413 of file FlutterMutatorViewTest.mm.

413 {
414 NSView* platformView = [[NSView alloc] init];
415 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
416
417 std::vector<FlutterPlatformViewMutation> mutations{
418 {
419 .type = kFlutterPlatformViewMutationTypeTransformation,
420 .transformation =
421 FlutterTransformation{
422 .scaleX = 1,
423 .transX = 100,
424 .scaleY = 1,
425 .transY = 50,
426 },
427 },
428 };
429
430 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations);
431
432 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(100, 50, 30, 20)));
433 EXPECT_EQ(mutatorView.pathClipViews.count, 0ull);
434
435 std::vector<FlutterPlatformViewMutation> mutations2{
436 {
437 .type = kFlutterPlatformViewMutationTypeClipRoundedRect,
438 .clip_rounded_rect =
439 FlutterRoundedRect{
440 .rect = FlutterRect{110, 60, 150, 150},
441 .upper_left_corner_radius = FlutterSize{10, 10},
442 .upper_right_corner_radius = FlutterSize{10, 10},
443 .lower_right_corner_radius = FlutterSize{10, 10},
444 .lower_left_corner_radius = FlutterSize{10, 10},
445 },
446 },
447 {
448 .type = kFlutterPlatformViewMutationTypeTransformation,
449 .transformation =
450 FlutterTransformation{
451 .scaleX = 1,
452 .transX = 100,
453 .scaleY = 1,
454 .transY = 50,
455 },
456 },
457 };
458
459 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations2);
460
461 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(110, 60, 20, 10)));
462 EXPECT_TRUE(
463 CGRectEqualToRect(mutatorView.subviews.firstObject.frame, CGRectMake(-10, -10, 30, 20)));
464 EXPECT_TRUE(CGRectEqualToRect(platformView.frame, CGRectMake(0, 0, 30, 20)));
465 EXPECT_EQ(mutatorView.pathClipViews.count, 1ul);
466
467 EXPECT_EQ(platformView.superview, mutatorView.platformViewContainer);
468 EXPECT_EQ(mutatorView.platformViewContainer.superview, mutatorView.pathClipViews[0]);
469 EXPECT_EQ(mutatorView.pathClipViews[0].superview, mutatorView);
470
471 std::vector<FlutterPlatformViewMutation> mutations3{
472 {
473 .type = kFlutterPlatformViewMutationTypeClipRoundedRect,
474 .clip_rounded_rect =
475 FlutterRoundedRect{
476 .rect = FlutterRect{110, 55, 150, 150},
477 .upper_left_corner_radius = FlutterSize{10, 10},
478 .upper_right_corner_radius = FlutterSize{10, 10},
479 .lower_right_corner_radius = FlutterSize{10, 10},
480 .lower_left_corner_radius = FlutterSize{10, 10},
481 },
482 },
483 {
484 .type = kFlutterPlatformViewMutationTypeClipRoundedRect,
485 .clip_rounded_rect =
486 FlutterRoundedRect{
487 .rect = FlutterRect{30, 30, 120, 65},
488 .upper_left_corner_radius = FlutterSize{10, 10},
489 .upper_right_corner_radius = FlutterSize{10, 10},
490 .lower_right_corner_radius = FlutterSize{10, 10},
491 .lower_left_corner_radius = FlutterSize{10, 10},
492 },
493 },
494 {
495 .type = kFlutterPlatformViewMutationTypeTransformation,
496 .transformation =
497 FlutterTransformation{
498 .scaleX = 1,
499 .transX = 100,
500 .scaleY = 1,
501 .transY = 50,
502 },
503 },
504 };
505
506 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations3);
507
508 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(110, 55, 10, 10)));
509 EXPECT_TRUE(
510 CGRectEqualToRect(mutatorView.subviews.firstObject.frame, CGRectMake(-10, -5, 30, 20)));
511 EXPECT_EQ(mutatorView.pathClipViews.count, 2ul);
512
513 EXPECT_EQ(platformView.superview, mutatorView.platformViewContainer);
514 EXPECT_EQ(mutatorView.platformViewContainer.superview, mutatorView.pathClipViews[1]);
515 EXPECT_EQ(mutatorView.pathClipViews[1].superview, mutatorView.pathClipViews[0]);
516 EXPECT_EQ(mutatorView.pathClipViews[0].superview, mutatorView);
517
518 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations2);
519
520 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(110, 60, 20, 10)));
521 EXPECT_TRUE(
522 CGRectEqualToRect(mutatorView.subviews.firstObject.frame, CGRectMake(-10, -10, 30, 20)));
523 EXPECT_TRUE(CGRectEqualToRect(platformView.frame, CGRectMake(0, 0, 30, 20)));
524 EXPECT_EQ(mutatorView.pathClipViews.count, 1ul);
525
526 EXPECT_EQ(platformView.superview, mutatorView.platformViewContainer);
527 EXPECT_EQ(mutatorView.platformViewContainer.superview, mutatorView.pathClipViews[0]);
528 EXPECT_EQ(mutatorView.pathClipViews[0].superview, mutatorView);
529
530 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations);
531
532 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(100, 50, 30, 20)));
533 EXPECT_EQ(mutatorView.pathClipViews.count, 0ull);
534 }

## ◆ TEST() [7/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | RectsClipsToPathWhenRotated |
| ) |  |

Definition at line 338 of file FlutterMutatorViewTest.mm.

338 {
339 NSView* platformView = [[NSView alloc] init];
340 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
341 std::vector<FlutterPlatformViewMutation> mutations{
342 {
343 .type = kFlutterPlatformViewMutationTypeTransformation,
344 // Roation M_PI / 8
345 .transformation =
346 FlutterTransformation{
347 .scaleX = 0.9238795325112867,
348 .skewX = -0.3826834323650898,
349 .skewY = 0.3826834323650898,
350 .scaleY = 0.9238795325112867,
351 },
352 },
353 {
354 .type = kFlutterPlatformViewMutationTypeClipRect,
355 .clip_rect = FlutterRect{110, 60, 150, 150},
356 },
357 {
358 .type = kFlutterPlatformViewMutationTypeTransformation,
359 .transformation =
360 FlutterTransformation{
361 .scaleX = 1,
362 .transX = 100,
363 .scaleY = 1,
364 .transY = 50,
365 },
366 },
367 };
368 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations);
369 EXPECT_EQ(mutatorView.pathClipViews.count, 1ul);
370 EXPECT_NEAR(mutatorView.platformViewContainer.frame.size.width, 35.370054622640396, kMaxErr);
371 EXPECT_NEAR(mutatorView.platformViewContainer.frame.size.height, 29.958093621178421, kMaxErr);
372 }

References kMaxErr.

## ◆ TEST() [8/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | RoundRectClipsToPath |
| ) |  |

Definition at line 374 of file FlutterMutatorViewTest.mm.

374 {
375 NSView* platformView = [[NSView alloc] init];
376 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
377
378 std::vector<FlutterPlatformViewMutation> mutations{
379 {
380 .type = kFlutterPlatformViewMutationTypeClipRoundedRect,
381 .clip_rounded_rect =
382 FlutterRoundedRect{
383 .rect = FlutterRect{110, 60, 150, 150},
384 .upper_left_corner_radius = FlutterSize{10, 10},
385 .upper_right_corner_radius = FlutterSize{10, 10},
386 .lower_right_corner_radius = FlutterSize{10, 10},
387 .lower_left_corner_radius = FlutterSize{10, 10},
388 },
389 },
390 {
391 .type = kFlutterPlatformViewMutationTypeTransformation,
392 .transformation =
393 FlutterTransformation{
394 .scaleX = 1,
395 .transX = 100,
396 .scaleY = 1,
397 .transY = 50,
398 },
399 },
400 };
401
402 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations);
403
404 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(110, 60, 20, 10)));
405 EXPECT_TRUE(
406 CGRectEqualToRect(mutatorView.subviews.firstObject.frame, CGRectMake(-10, -10, 30, 20)));
407 EXPECT_TRUE(CGRectEqualToRect(platformView.frame, CGRectMake(0, 0, 30, 20)));
408 EXPECT_EQ(mutatorView.pathClipViews.count, 1ul);
409 ExpectTransform3DEqual(mutatorView.pathClipViews.firstObject.layer.mask.transform,
410 CATransform3DMakeTranslation(-100, -50, 0));
411 }

## ◆ TEST() [9/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | RoundRectClipsToSimpleRectangle |
| ) |  |

Definition at line 262 of file FlutterMutatorViewTest.mm.

262 {
263 NSView* platformView = [[NSView alloc] init];
264 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
265
266 std::vector<FlutterPlatformViewMutation> mutations{
267 {
268 .type = kFlutterPlatformViewMutationTypeClipRoundedRect,
269 .clip_rounded_rect =
270 FlutterRoundedRect{
271 .rect = FlutterRect{110, 30, 120, 90},
272 .upper_left_corner_radius = FlutterSize{10, 10},
273 .upper_right_corner_radius = FlutterSize{10, 10},
274 .lower_right_corner_radius = FlutterSize{10, 10},
275 .lower_left_corner_radius = FlutterSize{10, 10},
276 },
277 },
278 {
279 .type = kFlutterPlatformViewMutationTypeTransformation,
280 .transformation =
281 FlutterTransformation{
282 .scaleX = 1,
283 .transX = 100,
284 .scaleY = 1,
285 .transY = 50,
286 },
287 },
288 };
289
290 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations);
291
292 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(110, 50, 10, 20)));
293 EXPECT_TRUE(
294 CGRectEqualToRect(mutatorView.subviews.firstObject.frame, CGRectMake(-10, 0, 30, 20)));
295 EXPECT_TRUE(CGRectEqualToRect(platformView.frame, CGRectMake(0, 0, 30, 20)));
296 EXPECT_EQ(mutatorView.pathClipViews.count, 0ul);
297 }

## ◆ TEST() [10/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | TransformedFrameIsCorrect |
| ) |  |

Definition at line 94 of file FlutterMutatorViewTest.mm.

94 {
95 NSView* platformView = [[NSView alloc] init];
96 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
97 NSView* mutatorViewParent = [[NSView alloc] init];
98 mutatorViewParent.wantsLayer = YES;
99 mutatorViewParent.layer.contentsScale = 2.0;
100 [mutatorViewParent addSubview:mutatorView];
101
102 std::vector<FlutterPlatformViewMutation> mutations{
103 {
104 .type = kFlutterPlatformViewMutationTypeTransformation,
105 .transformation =
106 FlutterTransformation{
107 .scaleX = 2,
108 .scaleY = 2,
109 },
110 },
111 {
112 .type = kFlutterPlatformViewMutationTypeTransformation,
113 .transformation =
114 FlutterTransformation{
115 .scaleX = 1,
116 .transX = 100,
117 .scaleY = 1,
118 .transY = 50,
119 },
120 },
121 {
122 .type = kFlutterPlatformViewMutationTypeTransformation,
123 .transformation =
124 FlutterTransformation{
125 .scaleX = 1.5,
126 .transX = -7.5,
127 .scaleY = 1.5,
128 .transY = -5,
129 },
130 },
131 };
132
133 // PlatformView size form engine comes in physical pixels
134 ApplyFlutterLayer(mutatorView, FlutterSize{30 * 2, 20 * 2}, mutations);
135 EXPECT_TRUE(CGRectEqualToRect(mutatorView.frame, CGRectMake(92.5, 45, 45, 30)));
136 EXPECT_TRUE(CGRectEqualToRect(platformView.frame, CGRectMake(0, 0, 30, 20)));
137
138 ExpectTransform3DEqual(mutatorView.platformViewContainer.layer.sublayerTransform,
139 CATransform3DMakeScale(1.5, 1.5, 1));
140 }

## ◆ TEST() [11/11]

TEST | ( | FlutterMutatorViewTest | ,
|  | ViewsSetIsFlipped |
| ) |  |

Definition at line 302 of file FlutterMutatorViewTest.mm.

302 {
303 NSView* platformView = [[NSView alloc] init];
304 FlutterMutatorView* mutatorView = [[FlutterMutatorView alloc] initWithPlatformView:platformView];
305
306 std::vector<FlutterPlatformViewMutation> mutations{
307 {
308 .type = kFlutterPlatformViewMutationTypeClipRoundedRect,
309 .clip_rounded_rect =
310 FlutterRoundedRect{
311 .rect = FlutterRect{110, 60, 150, 150},
312 .upper_left_corner_radius = FlutterSize{10, 10},
313 .upper_right_corner_radius = FlutterSize{10, 10},
314 .lower_right_corner_radius = FlutterSize{10, 10},
315 .lower_left_corner_radius = FlutterSize{10, 10},
316 },
317 },
318 {
319 .type = kFlutterPlatformViewMutationTypeTransformation,
320 .transformation =
321 FlutterTransformation{
322 .scaleX = 1,
323 .transX = 100,
324 .scaleY = 1,
325 .transY = 50,
326 },
327 },
328 };
329
330 ApplyFlutterLayer(mutatorView, FlutterSize{30, 20}, mutations);
331
332 EXPECT_TRUE(mutatorView.isFlipped);
333 ASSERT_EQ(mutatorView.pathClipViews.count, 1ul);
334 EXPECT_TRUE(mutatorView.pathClipViews.firstObject.isFlipped);
335 EXPECT_TRUE(mutatorView.platformViewContainer.isFlipped);
336 }

## Variable Documentation

## ◆ kMaxErr

constexpr float kMaxErr = 1e-10
| static constexpr

Definition at line 18 of file FlutterMutatorViewTest.mm.

Referenced by TEST().

FlutterMutatorView
Definition: FlutterMutatorView.h:42
FlutterMutatorView::platformView
NSView * platformView
Returns wrapped platform view.
Definition: FlutterMutatorView.h:48
kMaxErr
static constexpr float kMaxErr
Definition: FlutterMutatorViewTest.mm:18