Flutter Engine Uber Docs
Docs for the entire Flutter Engine repo.
 
Loading...
Searching...
No Matches
Classes | Functions
fl_event_channel_test.cc File Reference
#include "flutter/shell/platform/linux/testing/linux_test.h"
#include "gtest/gtest.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_event_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_method_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"
#include "flutter/shell/platform/linux/testing/fl_mock_binary_messenger.h"

Go to the source code of this file.

Classes

class  FlEventChannelTest
 

Functions

 TEST_F (FlEventChannelTest, Listen)
 
 TEST_F (FlEventChannelTest, ListenException)
 
 TEST_F (FlEventChannelTest, Cancel)
 
 TEST_F (FlEventChannelTest, CancelException)
 
 TEST_F (FlEventChannelTest, Args)
 
 TEST_F (FlEventChannelTest, SendEvents)
 
 TEST_F (FlEventChannelTest, ReuseChannel)
 
 TEST_F (FlEventChannelTest, ReplaceChannel)
 

Function Documentation

◆ TEST_F() [1/8]

TEST_F ( FlEventChannelTest  ,
Args   
)

Definition at line 162 of file fl_event_channel_test.cc.

162 {
163 g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
164 g_autoptr(FlEventChannel) channel = fl_event_channel_new(
165 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
166 int call_count = 0;
167 fl_event_channel_set_stream_handlers(
168 channel,
169 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
170 int* call_count = static_cast<int*>(user_data);
171 EXPECT_EQ(*call_count, 0);
172 (*call_count)++;
173
174 g_autoptr(FlValue) expected_args = fl_value_new_string("LISTEN-ARGS");
175 EXPECT_TRUE(fl_value_equal(args, expected_args));
176
177 return static_cast<FlMethodErrorResponse*>(nullptr);
178 },
179 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
180 int* call_count = static_cast<int*>(user_data);
181 EXPECT_EQ(*call_count, 1);
182 (*call_count)++;
183
184 g_autoptr(FlValue) expected_args = fl_value_new_string("CANCEL-ARGS");
185 EXPECT_TRUE(fl_value_equal(args, expected_args));
186
187 return static_cast<FlMethodErrorResponse*>(nullptr);
188 },
189 &call_count, nullptr);
190
191 g_autoptr(FlValue) listen_args = fl_value_new_string("LISTEN-ARGS");
192 fl_mock_binary_messenger_invoke_standard_method(
193 messenger, "test", "listen", listen_args,
194 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
195 gpointer user_data) {},
196 nullptr);
197 g_autoptr(FlValue) cancel_args = fl_value_new_string("CANCEL-ARGS");
198 fl_mock_binary_messenger_invoke_standard_method(
199 messenger, "test", "cancel", cancel_args,
200 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
201 gpointer user_data) {},
202 nullptr);
203
204 EXPECT_EQ(call_count, 2);
205}
g_autoptr
g_autoptr(FlEngine) engine
fl_event_channel_set_stream_handlers
G_MODULE_EXPORT void fl_event_channel_set_stream_handlers(FlEventChannel *self, FlEventChannelHandler listen_handler, FlEventChannelHandler cancel_handler, gpointer user_data, GDestroyNotify destroy_notify)
Definition fl_event_channel.cc:181
fl_event_channel_new
G_MODULE_EXPORT FlEventChannel * fl_event_channel_new(FlBinaryMessenger *messenger, const gchar *name, FlMethodCodec *codec)
Definition fl_event_channel.cc:159
args
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
Definition fl_event_channel.h:89
fl_mock_binary_messenger_invoke_standard_method
void fl_mock_binary_messenger_invoke_standard_method(FlMockBinaryMessenger *self, const gchar *channel, const char *name, FlValue *args, FlMockBinaryMessengerMethodCallback callback, gpointer user_data)
Definition fl_mock_binary_messenger.cc:818
channel
const gchar * channel
Definition fl_mock_binary_messenger.cc:204
fl_standard_method_codec_new
G_MODULE_EXPORT FlStandardMethodCodec * fl_standard_method_codec_new()
Definition fl_standard_method_codec.cc:291
fl_value_new_string
G_MODULE_EXPORT FlValue * fl_value_new_string(const gchar *value)
Definition fl_value.cc:276
fl_value_equal
G_MODULE_EXPORT bool fl_value_equal(FlValue *a, FlValue *b)
Definition fl_value.cc:471
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition fl_value.h:42
user_data
void * user_data
Definition texture_registrar_unittests.cc:27

References args, channel, fl_event_channel_new(), fl_event_channel_set_stream_handlers(), fl_mock_binary_messenger_invoke_standard_method(), fl_standard_method_codec_new(), fl_value_equal(), fl_value_new_string(), g_autoptr(), and user_data.

◆ TEST_F() [2/8]

TEST_F ( FlEventChannelTest  ,
Cancel   
)

Definition at line 88 of file fl_event_channel_test.cc.

88 {
89 g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
90 g_autoptr(FlEventChannel) channel = fl_event_channel_new(
91 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
92 fl_event_channel_set_stream_handlers(
93 channel, nullptr,
94 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
95 EXPECT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_NULL);
96
97 return static_cast<FlMethodErrorResponse*>(nullptr);
98 },
99 nullptr, nullptr);
100
101 fl_mock_binary_messenger_invoke_standard_method(
102 messenger, "test", "listen", nullptr,
103 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
104 gpointer user_data) {},
105 nullptr);
106 gboolean called = FALSE;
107 fl_mock_binary_messenger_invoke_standard_method(
108 messenger, "test", "cancel", nullptr,
109 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
110 gpointer user_data) {
111 gboolean* called = static_cast<gboolean*>(user_data);
112 *called = TRUE;
113
114 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
115 FlValue* result = fl_method_success_response_get_result(
116 FL_METHOD_SUCCESS_RESPONSE(response));
117 EXPECT_EQ(fl_value_get_type(result), FL_VALUE_TYPE_NULL);
118 },
119 &called);
120 EXPECT_TRUE(called);
121}
TRUE
return TRUE
Definition fl_compositor_software.cc:68
fl_method_success_response_get_result
G_MODULE_EXPORT FlValue * fl_method_success_response_get_result(FlMethodSuccessResponse *self)
Definition fl_method_response.cc:138
fl_value_get_type
G_MODULE_EXPORT FlValueType fl_value_get_type(FlValue *self)
Definition fl_value.cc:466
FL_VALUE_TYPE_NULL
@ FL_VALUE_TYPE_NULL
Definition fl_value.h:64

References args, channel, fl_event_channel_new(), fl_event_channel_set_stream_handlers(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_standard_method(), fl_standard_method_codec_new(), fl_value_get_type(), FL_VALUE_TYPE_NULL, g_autoptr(), TRUE, and user_data.

◆ TEST_F() [3/8]

TEST_F ( FlEventChannelTest  ,
CancelException   
)

Definition at line 124 of file fl_event_channel_test.cc.

124 {
125 g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
126 g_autoptr(FlEventChannel) channel = fl_event_channel_new(
127 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
128 fl_event_channel_set_stream_handlers(
129 channel, nullptr,
130 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
131 return fl_method_error_response_new("CANCEL-ERROR",
132 "CANCEL-ERROR-MESSAGE", nullptr);
133 },
134 nullptr, nullptr);
135
136 fl_mock_binary_messenger_invoke_standard_method(
137 messenger, "test", "listen", nullptr,
138 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
139 gpointer user_data) {},
140 nullptr);
141 gboolean called = FALSE;
142 fl_mock_binary_messenger_invoke_standard_method(
143 messenger, "test", "cancel", nullptr,
144 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
145 gpointer user_data) {
146 gboolean* called = static_cast<gboolean*>(user_data);
147 *called = TRUE;
148
149 EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
150 EXPECT_STREQ(fl_method_error_response_get_code(
151 FL_METHOD_ERROR_RESPONSE(response)),
152 "CANCEL-ERROR");
153 EXPECT_STREQ(fl_method_error_response_get_message(
154 FL_METHOD_ERROR_RESPONSE(response)),
155 "CANCEL-ERROR-MESSAGE");
156 },
157 &called);
158 EXPECT_TRUE(called);
159}
fl_method_error_response_new
G_MODULE_EXPORT FlMethodErrorResponse * fl_method_error_response_new(const gchar *code, const gchar *message, FlValue *details)
Definition fl_method_response.cc:144
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_error_response_get_code
G_MODULE_EXPORT const gchar * fl_method_error_response_get_code(FlMethodErrorResponse *self)
Definition fl_method_response.cc:160

References args, channel, fl_event_channel_new(), fl_event_channel_set_stream_handlers(), fl_method_error_response_get_code(), fl_method_error_response_get_message(), fl_method_error_response_new(), fl_mock_binary_messenger_invoke_standard_method(), fl_standard_method_codec_new(), g_autoptr(), TRUE, and user_data.

◆ TEST_F() [4/8]

TEST_F ( FlEventChannelTest  ,
Listen   
)

Definition at line 24 of file fl_event_channel_test.cc.

24 {
25 g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
26 g_autoptr(FlEventChannel) channel = fl_event_channel_new(
27 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
28 fl_event_channel_set_stream_handlers(
29 channel,
30 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
31 EXPECT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_NULL);
32
33 return static_cast<FlMethodErrorResponse*>(nullptr);
34 },
35 nullptr, nullptr, nullptr);
36
37 gboolean called = FALSE;
38 fl_mock_binary_messenger_invoke_standard_method(
39 messenger, "test", "listen", nullptr,
40 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
41 gpointer user_data) {
42 gboolean* called = static_cast<gboolean*>(user_data);
43 *called = TRUE;
44
45 EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
46 FlValue* result = fl_method_success_response_get_result(
47 FL_METHOD_SUCCESS_RESPONSE(response));
48 EXPECT_EQ(fl_value_get_type(result), FL_VALUE_TYPE_NULL);
49 },
50 &called);
51 EXPECT_TRUE(called);
52}

References args, channel, fl_event_channel_new(), fl_event_channel_set_stream_handlers(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_standard_method(), fl_standard_method_codec_new(), fl_value_get_type(), FL_VALUE_TYPE_NULL, g_autoptr(), TRUE, and user_data.

◆ TEST_F() [5/8]

TEST_F ( FlEventChannelTest  ,
ListenException   
)

Definition at line 55 of file fl_event_channel_test.cc.

55 {
56 g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
57 g_autoptr(FlEventChannel) channel = fl_event_channel_new(
58 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
59 fl_event_channel_set_stream_handlers(
60 channel,
61 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
62 return fl_method_error_response_new("LISTEN-ERROR",
63 "LISTEN-ERROR-MESSAGE", nullptr);
64 },
65 nullptr, nullptr, nullptr);
66
67 gboolean called = FALSE;
68 fl_mock_binary_messenger_invoke_standard_method(
69 messenger, "test", "listen", nullptr,
70 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
71 gpointer user_data) {
72 gboolean* called = static_cast<gboolean*>(user_data);
73 *called = TRUE;
74
75 EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
76 EXPECT_STREQ(fl_method_error_response_get_code(
77 FL_METHOD_ERROR_RESPONSE(response)),
78 "LISTEN-ERROR");
79 EXPECT_STREQ(fl_method_error_response_get_message(
80 FL_METHOD_ERROR_RESPONSE(response)),
81 "LISTEN-ERROR-MESSAGE");
82 },
83 &called);
84 EXPECT_TRUE(called);
85}

References args, channel, fl_event_channel_new(), fl_event_channel_set_stream_handlers(), fl_method_error_response_get_code(), fl_method_error_response_get_message(), fl_method_error_response_new(), fl_mock_binary_messenger_invoke_standard_method(), fl_standard_method_codec_new(), g_autoptr(), TRUE, and user_data.

◆ TEST_F() [6/8]

TEST_F ( FlEventChannelTest  ,
ReplaceChannel   
)

Definition at line 328 of file fl_event_channel_test.cc.

328 {
329 int event_count = 0;
330 fl_mock_binary_messenger_set_standard_event_channel(
331 messenger, "test",
332 [](FlMockBinaryMessenger* messenger, FlValue* event, gpointer user_data) {
333 int* event_count = static_cast<int*>(user_data);
334
335 EXPECT_EQ(fl_value_get_type(event), FL_VALUE_TYPE_INT);
336 EXPECT_EQ(fl_value_get_int(event), *event_count);
337
338 (*event_count)++;
339 },
340 [](FlMockBinaryMessenger* messenger, const gchar* code,
341 const gchar* message, FlValue* details, gpointer user_data) {},
342 &event_count);
343
344 g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
345 FlEventChannel* channel1 = fl_event_channel_new(
346 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
347 fl_event_channel_set_stream_handlers(
348 channel1,
349 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
350 // Send some events.
351 for (int i = 0; i < 5; i++) {
352 g_autoptr(FlValue) event = fl_value_new_int(100 + i);
353 g_autoptr(GError) error = nullptr;
354 EXPECT_TRUE(fl_event_channel_send(channel, event, nullptr, &error));
355 EXPECT_EQ(error, nullptr);
356 }
357
358 return static_cast<FlMethodErrorResponse*>(nullptr);
359 },
360 nullptr, nullptr, nullptr);
361
362 // Register a second channel with the same name.
363 g_autoptr(FlEventChannel) channel2 = fl_event_channel_new(
364 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
365 fl_event_channel_set_stream_handlers(
366 channel2,
367 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
368 // Send some events.
369 for (int i = 0; i < 5; i++) {
370 g_autoptr(FlValue) event = fl_value_new_int(i);
371 g_autoptr(GError) error = nullptr;
372 EXPECT_TRUE(fl_event_channel_send(channel, event, nullptr, &error));
373 EXPECT_EQ(error, nullptr);
374 }
375
376 return static_cast<FlMethodErrorResponse*>(nullptr);
377 },
378 nullptr, nullptr, nullptr);
379
380 fl_mock_binary_messenger_invoke_standard_method(
381 messenger, "test", "listen", nullptr,
382 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
383 gpointer user_data) {},
384 nullptr);
385 fl_mock_binary_messenger_invoke_standard_method(
386 messenger, "test", "cancel", nullptr,
387 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
388 gpointer user_data) {},
389 nullptr);
390
391 EXPECT_EQ(event_count, 5);
392}
message
const char * message
Definition fl_accessibility_handler.cc:21
fl_event_channel_send
G_MODULE_EXPORT gboolean fl_event_channel_send(FlEventChannel *self, FlValue *event, GCancellable *cancellable, GError **error)
Definition fl_event_channel.cc:196
fl_mock_binary_messenger_set_standard_event_channel
void fl_mock_binary_messenger_set_standard_event_channel(FlMockBinaryMessenger *self, const gchar *channel, FlMockBinaryMessengerEventChannelHandler handler, FlMockBinaryMessengerEventChannelErrorHandler error_handler, gpointer user_data)
Definition fl_mock_binary_messenger.cc:615
error
const uint8_t uint32_t uint32_t GError ** error
Definition fl_pixel_buffer_texture_test.cc:41
i
int i
Definition fl_socket_accessible.cc:18
fl_value_get_int
G_MODULE_EXPORT int64_t fl_value_get_int(FlValue *self)
Definition fl_value.cc:668
fl_value_new_int
G_MODULE_EXPORT FlValue * fl_value_new_int(int64_t value)
Definition fl_value.cc:262
FL_VALUE_TYPE_INT
@ FL_VALUE_TYPE_INT
Definition fl_value.h:66

References args, channel, error, fl_event_channel_new(), fl_event_channel_send(), fl_event_channel_set_stream_handlers(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_set_standard_event_channel(), fl_standard_method_codec_new(), fl_value_get_int(), fl_value_get_type(), fl_value_new_int(), FL_VALUE_TYPE_INT, g_autoptr(), i, message, and user_data.

◆ TEST_F() [7/8]

TEST_F ( FlEventChannelTest  ,
ReuseChannel   
)

Definition at line 258 of file fl_event_channel_test.cc.

258 {
259 int event_count = 0;
260 fl_mock_binary_messenger_set_standard_event_channel(
261 messenger, "test",
262 [](FlMockBinaryMessenger* messenger, FlValue* event, gpointer user_data) {
263 int* event_count = static_cast<int*>(user_data);
264
265 EXPECT_EQ(fl_value_get_type(event), FL_VALUE_TYPE_INT);
266 EXPECT_EQ(fl_value_get_int(event), *event_count);
267
268 (*event_count)++;
269 },
270 [](FlMockBinaryMessenger* messenger, const gchar* code,
271 const gchar* message, FlValue* details, gpointer user_data) {},
272 &event_count);
273
274 g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
275 FlEventChannel* channel1 = fl_event_channel_new(
276 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
277 fl_event_channel_set_stream_handlers(
278 channel1,
279 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
280 // Send some events.
281 for (int i = 0; i < 5; i++) {
282 g_autoptr(FlValue) event = fl_value_new_int(100 + i);
283 g_autoptr(GError) error = nullptr;
284 EXPECT_TRUE(fl_event_channel_send(channel, event, nullptr, &error));
285 EXPECT_EQ(error, nullptr);
286 }
287
288 return static_cast<FlMethodErrorResponse*>(nullptr);
289 },
290 nullptr, nullptr, nullptr);
291
292 // Remove this channel
293 g_object_unref(channel1);
294
295 // Register a second channel with the same name.
296 g_autoptr(FlEventChannel) channel2 = fl_event_channel_new(
297 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
298 fl_event_channel_set_stream_handlers(
299 channel2,
300 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
301 // Send some events.
302 for (int i = 0; i < 5; i++) {
303 g_autoptr(FlValue) event = fl_value_new_int(i);
304 g_autoptr(GError) error = nullptr;
305 EXPECT_TRUE(fl_event_channel_send(channel, event, nullptr, &error));
306 EXPECT_EQ(error, nullptr);
307 }
308
309 return static_cast<FlMethodErrorResponse*>(nullptr);
310 },
311 nullptr, nullptr, nullptr);
312
313 fl_mock_binary_messenger_invoke_standard_method(
314 messenger, "test", "listen", nullptr,
315 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
316 gpointer user_data) {},
317 nullptr);
318 fl_mock_binary_messenger_invoke_standard_method(
319 messenger, "test", "cancel", nullptr,
320 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
321 gpointer user_data) {},
322 nullptr);
323
324 EXPECT_EQ(event_count, 5);
325}

References args, channel, error, fl_event_channel_new(), fl_event_channel_send(), fl_event_channel_set_stream_handlers(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_set_standard_event_channel(), fl_standard_method_codec_new(), fl_value_get_int(), fl_value_get_type(), fl_value_new_int(), FL_VALUE_TYPE_INT, g_autoptr(), i, message, and user_data.

◆ TEST_F() [8/8]

TEST_F ( FlEventChannelTest  ,
SendEvents   
)

Definition at line 208 of file fl_event_channel_test.cc.

208 {
209 int event_count = 0;
210 fl_mock_binary_messenger_set_standard_event_channel(
211 messenger, "test",
212 [](FlMockBinaryMessenger* messenger, FlValue* event, gpointer user_data) {
213 int* event_count = static_cast<int*>(user_data);
214
215 EXPECT_EQ(fl_value_get_type(event), FL_VALUE_TYPE_INT);
216 EXPECT_EQ(fl_value_get_int(event), *event_count);
217
218 (*event_count)++;
219 },
220 [](FlMockBinaryMessenger* messenger, const gchar* code,
221 const gchar* message, FlValue* details, gpointer user_data) {},
222 &event_count);
223
224 g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
225 g_autoptr(FlEventChannel) channel = fl_event_channel_new(
226 FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
227 fl_event_channel_set_stream_handlers(
228 channel,
229 [](FlEventChannel* channel, FlValue* args, gpointer user_data) {
230 // Send some events.
231 for (int i = 0; i < 5; i++) {
232 g_autoptr(FlValue) event = fl_value_new_int(i);
233 g_autoptr(GError) error = nullptr;
234 EXPECT_TRUE(fl_event_channel_send(channel, event, nullptr, &error));
235 EXPECT_EQ(error, nullptr);
236 }
237
238 return static_cast<FlMethodErrorResponse*>(nullptr);
239 },
240 nullptr, nullptr, nullptr);
241
242 fl_mock_binary_messenger_invoke_standard_method(
243 messenger, "test", "listen", nullptr,
244 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
245 gpointer user_data) {},
246 nullptr);
247 fl_mock_binary_messenger_invoke_standard_method(
248 messenger, "test", "cancel", nullptr,
249 [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
250 gpointer user_data) {},
251 nullptr);
252
253 EXPECT_EQ(event_count, 5);
254}

References args, channel, error, fl_event_channel_new(), fl_event_channel_send(), fl_event_channel_set_stream_handlers(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_set_standard_event_channel(), fl_standard_method_codec_new(), fl_value_get_int(), fl_value_get_type(), fl_value_new_int(), FL_VALUE_TYPE_INT, g_autoptr(), i, message, and user_data.