| Flutter Linux Embedder |

fl_windowing_handler_test.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "flutter/shell/platform/linux/fl_windowing_handler.h"
6 #include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
7 #include "flutter/shell/platform/linux/fl_engine_private.h"
8 #include "flutter/shell/platform/linux/testing/fl_mock_binary_messenger.h"
9 #include "flutter/shell/platform/linux/testing/fl_test_gtk_logs.h"
10 #include "flutter/shell/platform/linux/testing/mock_gtk.h"
11 #include "flutter/testing/testing.h"
12
13 #include "gmock/gmock.h"
14 #include "gtest/gtest.h"
15
16 static void set_size_arg(FlValue* args,
17 const gchar* name,
18 double width,
19 double height) {
20 g_autoptr(FlValue) size_value = fl_value_new_list();
21 fl_value_append_take(size_value, fl_value_new_float(width));
22 fl_value_append_take(size_value, fl_value_new_float(height));
23 fl_value_set_string(args, name, size_value);
24 }
25
26 static FlValue* make_create_regular_args(double width, double height) {
27 FlValue* args = fl_value_new_map();
28 set_size_arg(args, "size", width, height);
29 return args;
30 }
31
32 static int64_t parse_create_regular_response(FlMethodResponse* response) {
33 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
34
35 FlValue* result = fl_method_success_response_get_result(
36 FL_METHOD_SUCCESS_RESPONSE(response));
37 EXPECT_EQ(fl_value_get_type(result), FL_VALUE_TYPE_MAP);
38
39 FlValue* view_id_value = fl_value_lookup_string(result, "viewId");
40 EXPECT_NE(view_id_value, nullptr);
41 EXPECT_EQ(fl_value_get_type(view_id_value), FL_VALUE_TYPE_INT);
42 int64_t view_id = fl_value_get_int(view_id_value);
43 EXPECT_GT(view_id, 0);
44
45 FlValue* size_value = fl_value_lookup_string(result, "size");
46 EXPECT_NE(size_value, nullptr);
47 EXPECT_EQ(fl_value_get_type(size_value), FL_VALUE_TYPE_LIST);
48 EXPECT_EQ(fl_value_get_length(size_value), 2u);
49 EXPECT_EQ(fl_value_get_type(fl_value_get_list_value(size_value, 0)),
50 FL_VALUE_TYPE_FLOAT);
51 EXPECT_EQ(fl_value_get_type(fl_value_get_list_value(size_value, 1)),
52 FL_VALUE_TYPE_FLOAT);
53
54 FlValue* state_value = fl_value_lookup_string(result, "state");
55 EXPECT_NE(state_value, nullptr);
56 EXPECT_EQ(fl_value_get_type(state_value), FL_VALUE_TYPE_STRING);
57
58 return view_id;
59 }
60
61 static FlValue* make_modify_regular_args(int64_t view_id) {
62 FlValue* args = fl_value_new_map();
63 fl_value_set_string_take(args, "viewId", fl_value_new_int(view_id));
64 return args;
65 }
66
67 static FlValue* make_destroy_window_args(int64_t view_id) {
68 FlValue* args = fl_value_new_map();
69 fl_value_set_string_take(args, "viewId", fl_value_new_int(view_id));
70 return args;
71 }
72
73 TEST(FlWindowingHandlerTest, CreateRegular) {
74 flutter::testing::fl_ensure_gtk_init();
75 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
76
77 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
78 g_autoptr(FlEngine) engine =
79 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
80 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
81
82 EXPECT_CALL(mock_gtk, gtk_window_new);
83 EXPECT_CALL(mock_gtk, gtk_window_set_default_size(::testing::_, 800, 600));
84
85 g_autoptr(FlValue) args = make_create_regular_args(800, 600);
86
87 gboolean called = FALSE;
88 fl_mock_binary_messenger_invoke_standard_method(
89 messenger, "flutter/windowing", "createRegular", args,
90 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
91 gpointer user_data) {
92 parse_create_regular_response(response);
93 gboolean* called = static_cast<gboolean*>(user_data);
94 *called = TRUE;
95 },
96 &called);
97 EXPECT_TRUE(called);
98
99 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
100 }
101
102 TEST(FlWindowingHandlerTest, CreateRegularMinSize) {
103 flutter::testing::fl_ensure_gtk_init();
104 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
105
106 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
107 g_autoptr(FlEngine) engine =
108 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
109 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
110
111 EXPECT_CALL(mock_gtk, gtk_window_new);
112 EXPECT_CALL(mock_gtk,
113 gtk_window_set_geometry_hints(
114 ::testing::_, nullptr,
115 ::testing::Pointee(::testing::AllOf(
116 ::testing::Field(&GdkGeometry::min_width, 100),
117 ::testing::Field(&GdkGeometry::min_height, 200))),
118 GDK_HINT_MIN_SIZE));
119
120 g_autoptr(FlValue) args = make_create_regular_args(800, 600);
121 set_size_arg(args, "minSize", 100, 200);
122
123 gboolean called = FALSE;
124 fl_mock_binary_messenger_invoke_standard_method(
125 messenger, "flutter/windowing", "createRegular", args,
126 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
127 gpointer user_data) {
128 parse_create_regular_response(response);
129 gboolean* called = static_cast<gboolean*>(user_data);
130 *called = TRUE;
131 },
132 &called);
133 EXPECT_TRUE(called);
134
135 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
136 }
137
138 TEST(FlWindowingHandlerTest, CreateRegularMaxSize) {
139 flutter::testing::fl_ensure_gtk_init();
140 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
141
142 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
143 g_autoptr(FlEngine) engine =
144 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
145 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
146
147 EXPECT_CALL(mock_gtk, gtk_window_new);
148 EXPECT_CALL(mock_gtk,
149 gtk_window_set_geometry_hints(
150 ::testing::_, nullptr,
151 ::testing::Pointee(::testing::AllOf(
152 ::testing::Field(&GdkGeometry::max_width, 1000),
153 ::testing::Field(&GdkGeometry::max_height, 2000))),
154 GDK_HINT_MAX_SIZE));
155
156 g_autoptr(FlValue) args = make_create_regular_args(800, 600);
157 set_size_arg(args, "maxSize", 1000, 2000);
158
159 gboolean called = FALSE;
160 fl_mock_binary_messenger_invoke_standard_method(
161 messenger, "flutter/windowing", "createRegular", args,
162 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
163 gpointer user_data) {
164 parse_create_regular_response(response);
165 gboolean* called = static_cast<gboolean*>(user_data);
166 *called = TRUE;
167 },
168 &called);
169 EXPECT_TRUE(called);
170
171 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
172 }
173
174 TEST(FlWindowingHandlerTest, CreateRegularWithTitle) {
175 flutter::testing::fl_ensure_gtk_init();
176 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
177
178 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
179 g_autoptr(FlEngine) engine =
180 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
181 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
182
183 EXPECT_CALL(mock_gtk, gtk_window_new);
184 EXPECT_CALL(mock_gtk,
185 gtk_window_set_title(::testing::_, ::testing::StrEq("TITLE")));
186
187 g_autoptr(FlValue) args = make_create_regular_args(800, 600);
188 fl_value_set_string_take(args, "title", fl_value_new_string("TITLE"));
189
190 gboolean called = FALSE;
191 fl_mock_binary_messenger_invoke_standard_method(
192 messenger, "flutter/windowing", "createRegular", args,
193 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
194 gpointer user_data) {
195 parse_create_regular_response(response);
196 gboolean* called = static_cast<gboolean*>(user_data);
197 *called = TRUE;
198 },
199 &called);
200 EXPECT_TRUE(called);
201
202 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
203 }
204
205 TEST(FlWindowingHandlerTest, CreateRegularMaximized) {
206 flutter::testing::fl_ensure_gtk_init();
207 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
208
209 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
210 g_autoptr(FlEngine) engine =
211 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
212 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
213
214 EXPECT_CALL(mock_gtk, gtk_window_new);
215 EXPECT_CALL(mock_gtk, gtk_window_maximize(::testing::_));
216
217 g_autoptr(FlValue) args = make_create_regular_args(800, 600);
218 fl_value_set_string_take(args, "state",
219 fl_value_new_string("WindowState.maximized"));
220
221 gboolean called = FALSE;
222 fl_mock_binary_messenger_invoke_standard_method(
223 messenger, "flutter/windowing", "createRegular", args,
224 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
225 gpointer user_data) {
226 parse_create_regular_response(response);
227 gboolean* called = static_cast<gboolean*>(user_data);
228 *called = TRUE;
229 },
230 &called);
231 EXPECT_TRUE(called);
232
233 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
234 }
235
236 TEST(FlWindowingHandlerTest, CreateRegularMinimized) {
237 flutter::testing::fl_ensure_gtk_init();
238 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
239
240 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
241 g_autoptr(FlEngine) engine =
242 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
243 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
244
245 EXPECT_CALL(mock_gtk, gtk_window_new);
246 EXPECT_CALL(mock_gtk, gtk_window_iconify(::testing::_));
247
248 g_autoptr(FlValue) args = make_create_regular_args(800, 600);
249 fl_value_set_string_take(args, "state",
250 fl_value_new_string("WindowState.minimized"));
251
252 gboolean called = FALSE;
253 fl_mock_binary_messenger_invoke_standard_method(
254 messenger, "flutter/windowing", "createRegular", args,
255 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
256 gpointer user_data) {
257 parse_create_regular_response(response);
258 gboolean* called = static_cast<gboolean*>(user_data);
259 *called = TRUE;
260 },
261 &called);
262 EXPECT_TRUE(called);
263
264 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
265 }
266
267 TEST(FlWindowingHandlerTest, ModifyRegularSize) {
268 flutter::testing::fl_ensure_gtk_init();
269 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
270
271 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
272 g_autoptr(FlEngine) engine =
273 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
274 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
275
276 EXPECT_CALL(mock_gtk, gtk_window_new);
277 EXPECT_CALL(mock_gtk, gtk_window_resize(::testing::_, 1024, 768));
278
279 g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
280
281 int64_t view_id = -1;
282 fl_mock_binary_messenger_invoke_standard_method(
283 messenger, "flutter/windowing", "createRegular", create_args,
284 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
285 gpointer user_data) {
286 int64_t* view_id = static_cast<int64_t*>(user_data);
287 *view_id = parse_create_regular_response(response);
288 },
289 &view_id);
290 EXPECT_GT(view_id, 0);
291
292 g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
293 set_size_arg(modify_args, "size", 1024, 768);
294
295 gboolean modify_called = FALSE;
296 fl_mock_binary_messenger_invoke_standard_method(
297 messenger, "flutter/windowing", "modifyRegular", modify_args,
298 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
299 gpointer user_data) {
300 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
301 gboolean* called = static_cast<gboolean*>(user_data);
302 *called = TRUE;
303 },
304 &modify_called);
305 EXPECT_TRUE(modify_called);
306
307 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
308 }
309
310 TEST(FlWindowingHandlerTest, ModifyRegularTitle) {
311 flutter::testing::fl_ensure_gtk_init();
312 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
313
314 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
315 g_autoptr(FlEngine) engine =
316 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
317 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
318
319 EXPECT_CALL(mock_gtk, gtk_window_new);
320 EXPECT_CALL(mock_gtk,
321 gtk_window_set_title(::testing::_, ::testing::StrEq("TITLE")));
322
323 g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
324
325 int64_t view_id = -1;
326 fl_mock_binary_messenger_invoke_standard_method(
327 messenger, "flutter/windowing", "createRegular", create_args,
328 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
329 gpointer user_data) {
330 int64_t* view_id = static_cast<int64_t*>(user_data);
331 *view_id = parse_create_regular_response(response);
332 },
333 &view_id);
334 EXPECT_GT(view_id, 0);
335
336 g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
337 fl_value_set_string_take(modify_args, "title", fl_value_new_string("TITLE"));
338
339 gboolean modify_called = FALSE;
340 fl_mock_binary_messenger_invoke_standard_method(
341 messenger, "flutter/windowing", "modifyRegular", modify_args,
342 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
343 gpointer user_data) {
344 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
345 gboolean* called = static_cast<gboolean*>(user_data);
346 *called = TRUE;
347 },
348 &modify_called);
349 EXPECT_TRUE(modify_called);
350
351 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
352 }
353
354 TEST(FlWindowingHandlerTest, ModifyRegularMaximize) {
355 flutter::testing::fl_ensure_gtk_init();
356 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
357
358 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
359 g_autoptr(FlEngine) engine =
360 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
361 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
362
363 EXPECT_CALL(mock_gtk, gtk_window_new);
364
365 g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
366
367 int64_t view_id = -1;
368 fl_mock_binary_messenger_invoke_standard_method(
369 messenger, "flutter/windowing", "createRegular", create_args,
370 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
371 gpointer user_data) {
372 int64_t* view_id = static_cast<int64_t*>(user_data);
373 *view_id = parse_create_regular_response(response);
374 },
375 &view_id);
376 EXPECT_GT(view_id, 0);
377
378 EXPECT_CALL(mock_gtk, gtk_window_maximize(::testing::_));
379
380 g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
381 fl_value_set_string_take(modify_args, "state",
382 fl_value_new_string("WindowState.maximized"));
383
384 gboolean modify_called = FALSE;
385 fl_mock_binary_messenger_invoke_standard_method(
386 messenger, "flutter/windowing", "modifyRegular", modify_args,
387 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
388 gpointer user_data) {
389 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
390 gboolean* called = static_cast<gboolean*>(user_data);
391 *called = TRUE;
392 },
393 &modify_called);
394 EXPECT_TRUE(modify_called);
395
396 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
397 }
398
399 TEST(FlWindowingHandlerTest, ModifyRegularUnmaximize) {
400 flutter::testing::fl_ensure_gtk_init();
401 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
402
403 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
404 g_autoptr(FlEngine) engine =
405 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
406 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
407
408 EXPECT_CALL(mock_gtk, gtk_window_new);
409 EXPECT_CALL(mock_gtk, gtk_window_maximize(::testing::_));
410
411 g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
412 fl_value_set_string_take(create_args, "state",
413 fl_value_new_string("WindowState.maximized"));
414
415 int64_t view_id = -1;
416 fl_mock_binary_messenger_invoke_standard_method(
417 messenger, "flutter/windowing", "createRegular", create_args,
418 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
419 gpointer user_data) {
420 int64_t* view_id = static_cast<int64_t*>(user_data);
421 *view_id = parse_create_regular_response(response);
422 },
423 &view_id);
424 EXPECT_GT(view_id, 0);
425
426 EXPECT_CALL(mock_gtk, gtk_window_is_maximized(::testing::_))
427 .WillOnce(::testing::Return(TRUE));
428 EXPECT_CALL(mock_gtk, gtk_window_unmaximize(::testing::_));
429
430 g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
431 fl_value_set_string_take(modify_args, "state",
432 fl_value_new_string("WindowState.restored"));
433
434 gboolean modify_called = FALSE;
435 fl_mock_binary_messenger_invoke_standard_method(
436 messenger, "flutter/windowing", "modifyRegular", modify_args,
437 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
438 gpointer user_data) {
439 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
440 gboolean* called = static_cast<gboolean*>(user_data);
441 *called = TRUE;
442 },
443 &modify_called);
444 EXPECT_TRUE(modify_called);
445
446 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
447 }
448
449 TEST(FlWindowingHandlerTest, ModifyRegularMinimize) {
450 flutter::testing::fl_ensure_gtk_init();
451 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
452
453 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
454 g_autoptr(FlEngine) engine =
455 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
456 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
457
458 EXPECT_CALL(mock_gtk, gtk_window_new);
459
460 g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
461
462 int64_t view_id = -1;
463 fl_mock_binary_messenger_invoke_standard_method(
464 messenger, "flutter/windowing", "createRegular", create_args,
465 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
466 gpointer user_data) {
467 int64_t* view_id = static_cast<int64_t*>(user_data);
468 *view_id = parse_create_regular_response(response);
469 },
470 &view_id);
471 EXPECT_GT(view_id, 0);
472
473 EXPECT_CALL(mock_gtk, gtk_window_iconify(::testing::_));
474
475 g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
476 fl_value_set_string_take(modify_args, "state",
477 fl_value_new_string("WindowState.minimized"));
478
479 gboolean modify_called = FALSE;
480 fl_mock_binary_messenger_invoke_standard_method(
481 messenger, "flutter/windowing", "modifyRegular", modify_args,
482 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
483 gpointer user_data) {
484 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
485 gboolean* called = static_cast<gboolean*>(user_data);
486 *called = TRUE;
487 },
488 &modify_called);
489 EXPECT_TRUE(modify_called);
490
491 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
492 }
493
494 TEST(FlWindowingHandlerTest, ModifyRegularUnminimize) {
495 flutter::testing::fl_ensure_gtk_init();
496 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
497
498 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
499 g_autoptr(FlEngine) engine =
500 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
501 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
502
503 EXPECT_CALL(mock_gtk, gtk_window_new);
504 EXPECT_CALL(mock_gtk, gtk_window_iconify(::testing::_));
505
506 g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
507 fl_value_set_string_take(create_args, "state",
508 fl_value_new_string("WindowState.minimized"));
509
510 int64_t view_id = -1;
511 fl_mock_binary_messenger_invoke_standard_method(
512 messenger, "flutter/windowing", "createRegular", create_args,
513 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
514 gpointer user_data) {
515 int64_t* view_id = static_cast<int64_t*>(user_data);
516 *view_id = parse_create_regular_response(response);
517 },
518 &view_id);
519 EXPECT_GT(view_id, 0);
520
521 EXPECT_CALL(mock_gtk, gdk_window_get_state(::testing::_))
522 .WillOnce(::testing::Return(GDK_WINDOW_STATE_ICONIFIED));
523 EXPECT_CALL(mock_gtk, gtk_window_deiconify(::testing::_));
524
525 g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
526 fl_value_set_string_take(modify_args, "state",
527 fl_value_new_string("WindowState.restored"));
528
529 gboolean modify_called = FALSE;
530 fl_mock_binary_messenger_invoke_standard_method(
531 messenger, "flutter/windowing", "modifyRegular", modify_args,
532 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
533 gpointer user_data) {
534 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
535 gboolean* called = static_cast<gboolean*>(user_data);
536 *called = TRUE;
537 },
538 &modify_called);
539 EXPECT_TRUE(modify_called);
540
541 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
542 }
543
544 TEST(FlWindowingHandlerTest, ModifyUnknownWindow) {
545 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
546 g_autoptr(FlEngine) engine =
547 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
548 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
549
550 g_autoptr(FlValue) args = make_modify_regular_args(99);
551
552 gboolean called = FALSE;
553 fl_mock_binary_messenger_invoke_standard_method(
554 messenger, "flutter/windowing", "modifyRegular", args,
555 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
556 gpointer user_data) {
557 EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
558 EXPECT_STREQ(fl_method_error_response_get_code(
559 FL_METHOD_ERROR_RESPONSE(response)),
560 "Bad Arguments");
561 EXPECT_STREQ(fl_method_error_response_get_message(
562 FL_METHOD_ERROR_RESPONSE(response)),
563 "No window with given view ID");
564 gboolean* called = static_cast<gboolean*>(user_data);
565 *called = TRUE;
566 },
567 &called);
568 EXPECT_TRUE(called);
569
570 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
571 }
572
573 TEST(FlWindowingHandlerTest, DestroyWindow) {
574 flutter::testing::fl_ensure_gtk_init();
575 ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
576
577 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
578 g_autoptr(FlEngine) engine =
579 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
580 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
581
582 EXPECT_CALL(mock_gtk, gtk_window_new);
583 EXPECT_CALL(mock_gtk, gtk_widget_destroy);
584
585 g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
586
587 int64_t view_id = -1;
588 fl_mock_binary_messenger_invoke_standard_method(
589 messenger, "flutter/windowing", "createRegular", create_args,
590 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
591 gpointer user_data) {
592 int64_t* view_id = static_cast<int64_t*>(user_data);
593 *view_id = parse_create_regular_response(response);
594 },
595 &view_id);
596 EXPECT_GT(view_id, 0);
597
598 g_autoptr(FlValue) destroy_args = make_destroy_window_args(view_id);
599 gboolean destroy_called = FALSE;
600 fl_mock_binary_messenger_invoke_standard_method(
601 messenger, "flutter/windowing", "destroyWindow", destroy_args,
602 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
603 gpointer user_data) {
604 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
605 gboolean* called = static_cast<gboolean*>(user_data);
606 *called = TRUE;
607 },
608 &destroy_called);
609 EXPECT_TRUE(destroy_called);
610
611 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
612 }
613
614 TEST(FlWindowingHandlerTest, DestroyUnknownWindow) {
615 g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
616 g_autoptr(FlEngine) engine =
617 fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
618 g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
619
620 g_autoptr(FlValue) args = make_destroy_window_args(99);
621 gboolean called = FALSE;
622 fl_mock_binary_messenger_invoke_standard_method(
623 messenger, "flutter/windowing", "destroyWindow", args,
624 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
625 gpointer user_data) {
626 EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
627 EXPECT_STREQ(fl_method_error_response_get_code(
628 FL_METHOD_ERROR_RESPONSE(response)),
629 "Bad Arguments");
630 EXPECT_STREQ(fl_method_error_response_get_message(
631 FL_METHOD_ERROR_RESPONSE(response)),
632 "No window with given view ID");
633 gboolean* called = static_cast<gboolean*>(user_data);
634 *called = TRUE;
635 },
636 &called);
637 EXPECT_TRUE(called);
638
639 fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
640 }
fl_binary_messenger_shutdown
void fl_binary_messenger_shutdown(FlBinaryMessenger *self)
Definition: fl_binary_messenger.cc:500
fl_binary_messenger_private.h
fl_engine_new_with_binary_messenger
FlEngine * fl_engine_new_with_binary_messenger(FlBinaryMessenger *binary_messenger)
Definition: fl_engine.cc:695
fl_engine_private.h
args
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
Definition: fl_event_channel.h:89
user_data
G_BEGIN_DECLS G_MODULE_EXPORT FlValue gpointer user_data
Definition: fl_event_channel.h:90
fl_method_error_response_get_code
G_MODULE_EXPORT const gchar * fl_method_error_response_get_code(FlMethodErrorResponse *self)
Definition: fl_method_response.cc:160
fl_method_error_response_get_message
G_MODULE_EXPORT const gchar * fl_method_error_response_get_message(FlMethodErrorResponse *self)
Definition: fl_method_response.cc:166
fl_method_success_response_get_result
G_MODULE_EXPORT FlValue * fl_method_success_response_get_result(FlMethodSuccessResponse *self)
Definition: fl_method_response.cc:138
height
const uint8_t uint32_t uint32_t * height
Definition: fl_pixel_buffer_texture_test.cc:39
width
const uint8_t uint32_t * width
Definition: fl_pixel_buffer_texture_test.cc:38
TRUE
return TRUE
Definition: fl_pixel_buffer_texture_test.cc:53
fl_value_set_string
G_MODULE_EXPORT void fl_value_set_string(FlValue *self, const gchar *key, FlValue *value)
Definition: fl_value.cc:639
fl_value_new_float
G_MODULE_EXPORT FlValue * fl_value_new_float(double value)
Definition: fl_value.cc:269
fl_value_lookup_string
G_MODULE_EXPORT FlValue * fl_value_lookup_string(FlValue *self, const gchar *key)
Definition: fl_value.cc:811
fl_value_set_string_take
G_MODULE_EXPORT void fl_value_set_string_take(FlValue *self, const gchar *key, FlValue *value)
Definition: fl_value.cc:650
fl_value_get_list_value
G_MODULE_EXPORT FlValue * fl_value_get_list_value(FlValue *self, size_t index)
Definition: fl_value.cc:776
fl_value_get_int
G_MODULE_EXPORT int64_t fl_value_get_int(FlValue *self)
Definition: fl_value.cc:668
fl_value_new_string
G_MODULE_EXPORT FlValue * fl_value_new_string(const gchar *value)
Definition: fl_value.cc:276
fl_value_get_type
G_MODULE_EXPORT FlValueType fl_value_get_type(FlValue *self)
Definition: fl_value.cc:466
fl_value_new_list
G_MODULE_EXPORT FlValue * fl_value_new_list()
Definition: fl_value.cc:349
fl_value_append_take
G_MODULE_EXPORT void fl_value_append_take(FlValue *self, FlValue *value)
Definition: fl_value.cc:600
fl_value_new_int
G_MODULE_EXPORT FlValue * fl_value_new_int(int64_t value)
Definition: fl_value.cc:262
fl_value_new_map
G_MODULE_EXPORT FlValue * fl_value_new_map()
Definition: fl_value.cc:366
fl_value_get_length
G_MODULE_EXPORT size_t fl_value_get_length(FlValue *self)
Definition: fl_value.cc:724
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42
FL_VALUE_TYPE_STRING
@ FL_VALUE_TYPE_STRING
Definition: fl_value.h:68
FL_VALUE_TYPE_INT
@ FL_VALUE_TYPE_INT
Definition: fl_value.h:66
FL_VALUE_TYPE_LIST
@ FL_VALUE_TYPE_LIST
Definition: fl_value.h:73
FL_VALUE_TYPE_MAP
@ FL_VALUE_TYPE_MAP
Definition: fl_value.h:74
FL_VALUE_TYPE_FLOAT
@ FL_VALUE_TYPE_FLOAT
Definition: fl_value.h:67
view_id
G_BEGIN_DECLS FlutterViewId view_id
Definition: fl_view_accessible.h:49
fl_windowing_handler_new
FlWindowingHandler * fl_windowing_handler_new(FlEngine *engine)
Definition: fl_windowing_handler.cc:260
fl_windowing_handler.h
TEST
TEST(FlWindowingHandlerTest, CreateRegular)
Definition: fl_windowing_handler_test.cc:73
make_destroy_window_args
static FlValue * make_destroy_window_args(int64_t view_id)
Definition: fl_windowing_handler_test.cc:67
parse_create_regular_response
static int64_t parse_create_regular_response(FlMethodResponse *response)
Definition: fl_windowing_handler_test.cc:32
make_create_regular_args
static FlValue * make_create_regular_args(double width, double height)
Definition: fl_windowing_handler_test.cc:26
make_modify_regular_args
static FlValue * make_modify_regular_args(int64_t view_id)
Definition: fl_windowing_handler_test.cc:61
set_size_arg
static void set_size_arg(FlValue *args, const gchar *name, double width, double height)
Definition: fl_windowing_handler_test.cc:16