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_window.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::MockWindow> mock_window;
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_window, gtk_window_new);
83  EXPECT_CALL(mock_window, 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::MockWindow> mock_window;
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_window, gtk_window_new);
112  EXPECT_CALL(mock_window,
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::MockWindow> mock_window;
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_window, gtk_window_new);
148  EXPECT_CALL(mock_window,
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::MockWindow> mock_window;
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_window, gtk_window_new);
184  EXPECT_CALL(mock_window,
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::MockWindow> mock_window;
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_window, gtk_window_new);
215  EXPECT_CALL(mock_window, 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::MockWindow> mock_window;
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_window, gtk_window_new);
246  EXPECT_CALL(mock_window, 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::MockWindow> mock_window;
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_window, gtk_window_new);
277  EXPECT_CALL(mock_window, 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::MockWindow> mock_window;
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_window, gtk_window_new);
320  EXPECT_CALL(mock_window,
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::MockWindow> mock_window;
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_window, 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_window, 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::MockWindow> mock_window;
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_window, gtk_window_new);
409  EXPECT_CALL(mock_window, 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_window, gtk_window_is_maximized(::testing::_))
427  .WillOnce(::testing::Return(TRUE));
428  EXPECT_CALL(mock_window, 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::MockWindow> mock_window;
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_window, 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_window, 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::MockWindow> mock_window;
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_window, gtk_window_new);
504  EXPECT_CALL(mock_window, 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_window, gdk_window_get_state(::testing::_))
522  .WillOnce(::testing::Return(GDK_WINDOW_STATE_ICONIFIED));
523  EXPECT_CALL(mock_window, 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::MockWindow> mock_window;
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_window, gtk_window_new);
583  EXPECT_CALL(mock_window, 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_VALUE_TYPE_MAP
@ FL_VALUE_TYPE_MAP
Definition: fl_value.h:74
make_create_regular_args
static FlValue * make_create_regular_args(double width, double height)
Definition: fl_windowing_handler_test.cc:26
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
set_size_arg
static void set_size_arg(FlValue *args, const gchar *name, double width, double height)
Definition: fl_windowing_handler_test.cc:16
fl_value_new_list
G_MODULE_EXPORT FlValue * fl_value_new_list()
Definition: fl_value.cc:349
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42
TEST
TEST(FlWindowingHandlerTest, CreateRegular)
Definition: fl_windowing_handler_test.cc:73
make_modify_regular_args
static FlValue * make_modify_regular_args(int64_t view_id)
Definition: fl_windowing_handler_test.cc:61
FL_VALUE_TYPE_LIST
@ FL_VALUE_TYPE_LIST
Definition: fl_value.h:73
fl_value_lookup_string
G_MODULE_EXPORT FlValue * fl_value_lookup_string(FlValue *self, const gchar *key)
Definition: fl_value.cc:811
fl_value_new_int
G_MODULE_EXPORT FlValue * fl_value_new_int(int64_t value)
Definition: fl_value.cc:262
fl_method_error_response_get_message
const G_MODULE_EXPORT gchar * fl_method_error_response_get_message(FlMethodErrorResponse *self)
Definition: fl_method_response.cc:166
fl_value_get_int
G_MODULE_EXPORT int64_t fl_value_get_int(FlValue *self)
Definition: fl_value.cc:668
user_data
G_BEGIN_DECLS G_MODULE_EXPORT FlValue gpointer user_data
Definition: fl_event_channel.h:90
fl_value_new_map
G_MODULE_EXPORT FlValue * fl_value_new_map()
Definition: fl_value.cc:366
fl_value_get_type
G_MODULE_EXPORT FlValueType fl_value_get_type(FlValue *self)
Definition: fl_value.cc:466
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_TYPE_STRING
@ FL_VALUE_TYPE_STRING
Definition: fl_value.h:68
parse_create_regular_response
static int64_t parse_create_regular_response(FlMethodResponse *response)
Definition: fl_windowing_handler_test.cc:32
fl_engine_private.h
fl_method_success_response_get_result
G_MODULE_EXPORT FlValue * fl_method_success_response_get_result(FlMethodSuccessResponse *self)
Definition: fl_method_response.cc:138
TRUE
return TRUE
Definition: fl_pixel_buffer_texture_test.cc:53
make_destroy_window_args
static FlValue * make_destroy_window_args(int64_t view_id)
Definition: fl_windowing_handler_test.cc:67
fl_value_append_take
G_MODULE_EXPORT void fl_value_append_take(FlValue *self, FlValue *value)
Definition: fl_value.cc:600
fl_value_get_length
G_MODULE_EXPORT size_t fl_value_get_length(FlValue *self)
Definition: fl_value.cc:724
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_TYPE_INT
@ FL_VALUE_TYPE_INT
Definition: fl_value.h:66
height
const uint8_t uint32_t uint32_t * height
Definition: fl_pixel_buffer_texture_test.cc:39
fl_binary_messenger_private.h
fl_method_error_response_get_code
const G_MODULE_EXPORT gchar * fl_method_error_response_get_code(FlMethodErrorResponse *self)
Definition: fl_method_response.cc:160
args
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
Definition: fl_event_channel.h:89
FL_VALUE_TYPE_FLOAT
@ FL_VALUE_TYPE_FLOAT
Definition: fl_value.h:67
fl_windowing_handler.h
fl_value_new_float
G_MODULE_EXPORT FlValue * fl_value_new_float(double value)
Definition: fl_value.cc:269
width
const uint8_t uint32_t * width
Definition: fl_pixel_buffer_texture_test.cc:38
fl_engine_new_with_binary_messenger
FlEngine * fl_engine_new_with_binary_messenger(FlBinaryMessenger *binary_messenger)
Definition: fl_engine.cc:585
fl_windowing_handler_new
FlWindowingHandler * fl_windowing_handler_new(FlEngine *engine)
Definition: fl_windowing_handler.cc:260
fl_value_new_string
G_MODULE_EXPORT FlValue * fl_value_new_string(const gchar *value)
Definition: fl_value.cc:276