6 #include "gtest/gtest.h"
11 #include "flutter/shell/platform/embedder/embedder.h"
12 #include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
19 TEST(FlBinaryMessengerTest, Send) {
20 g_autoptr(GMainLoop) loop = g_main_loop_new(
nullptr, 0);
25 g_autoptr(GError)
error =
nullptr;
27 EXPECT_EQ(
error,
nullptr);
29 FlutterDataCallback response_callback;
30 void* response_callback_user_data;
33 PlatformMessageCreateResponseHandle,
34 ([&response_callback, &response_callback_user_data](
35 auto engine, FlutterDataCallback data_callback,
void*
user_data,
36 FlutterPlatformMessageResponseHandle** response_out) {
37 response_callback = data_callback;
43 ([&response_callback, &response_callback_user_data](
44 auto engine,
const FlutterPlatformMessage* message) {
45 EXPECT_STREQ(message->channel,
"test");
46 g_autofree gchar* text =
47 g_strndup(
reinterpret_cast<const gchar*
>(message->message),
48 message->message_size);
49 EXPECT_STREQ(text,
"Marco!");
51 const gchar* response =
"Polo!";
52 response_callback(
reinterpret_cast<const uint8_t*
>(response),
53 strlen(response), response_callback_user_data);
59 const char* text =
"Marco!";
60 g_autoptr(GBytes) message = g_bytes_new(text, strlen(text));
62 messenger,
"test", message,
nullptr,
63 [](GObject*
object, GAsyncResult* result, gpointer
user_data) {
64 g_autoptr(GError)
error =
nullptr;
66 FL_BINARY_MESSENGER(
object), result, &
error);
67 EXPECT_NE(message,
nullptr);
68 EXPECT_EQ(
error,
nullptr);
70 g_autofree gchar* text = g_strndup(
71 static_cast<const gchar*
>(g_bytes_get_data(message,
nullptr)),
72 g_bytes_get_size(message));
73 EXPECT_STREQ(text,
"Polo!");
75 g_main_loop_quit(
static_cast<GMainLoop*
>(
user_data));
79 g_main_loop_run(loop);
83 TEST(FlBinaryMessengerTest, SendNullptr) {
87 g_autoptr(GError)
error =
nullptr;
89 EXPECT_EQ(
error,
nullptr);
94 ([&called](
auto engine,
const FlutterPlatformMessage* message) {
97 EXPECT_STREQ(message->channel,
"test");
100 EXPECT_EQ(message->message_size,
static_cast<size_t>(0));
112 TEST(FlBinaryMessengerTest, SendEmpty) {
116 g_autoptr(GError)
error =
nullptr;
118 EXPECT_EQ(
error,
nullptr);
123 ([&called](
auto engine,
const FlutterPlatformMessage* message) {
126 EXPECT_STREQ(message->channel,
"test");
127 EXPECT_EQ(message->message_size,
static_cast<size_t>(0));
132 g_autoptr(GBytes) message = g_bytes_new(
nullptr, 0);
139 TEST(FlBinaryMessengerTest, NullptrResponse) {
140 g_autoptr(GMainLoop) loop = g_main_loop_new(
nullptr, 0);
145 g_autoptr(GError)
error =
nullptr;
147 EXPECT_EQ(
error,
nullptr);
149 FlutterDataCallback response_callback;
150 void* response_callback_user_data;
153 PlatformMessageCreateResponseHandle,
154 ([&response_callback, &response_callback_user_data](
155 auto engine, FlutterDataCallback data_callback,
void*
user_data,
156 FlutterPlatformMessageResponseHandle** response_out) {
157 response_callback = data_callback;
163 ([&response_callback, &response_callback_user_data](
164 auto engine,
const FlutterPlatformMessage* message) {
165 EXPECT_STREQ(message->channel,
"test");
166 g_autofree gchar* text =
167 g_strndup(
reinterpret_cast<const gchar*
>(message->message),
168 message->message_size);
169 EXPECT_STREQ(text,
"Hello World!");
171 response_callback(
nullptr, 0, response_callback_user_data);
177 const char* text =
"Hello World!";
178 g_autoptr(GBytes) message = g_bytes_new(text, strlen(text));
180 messenger,
"test", message,
nullptr,
181 [](GObject*
object, GAsyncResult* result, gpointer
user_data) {
182 g_autoptr(GError)
error =
nullptr;
184 FL_BINARY_MESSENGER(
object), result, &
error);
185 EXPECT_NE(message,
nullptr);
186 EXPECT_EQ(
error,
nullptr);
188 EXPECT_EQ(g_bytes_get_size(message),
static_cast<gsize
>(0));
190 g_main_loop_quit(
static_cast<GMainLoop*
>(
user_data));
194 g_main_loop_run(loop);
198 TEST(FlBinaryMessengerTest, SendFailure) {
199 g_autoptr(GMainLoop) loop = g_main_loop_new(
nullptr, 0);
204 g_autoptr(GError)
error =
nullptr;
206 EXPECT_EQ(
error,
nullptr);
209 MOCK_ENGINE_PROC(SendPlatformMessage,
210 ([](
auto engine,
const FlutterPlatformMessage* message) {
211 EXPECT_STREQ(message->channel,
"test");
212 return kInternalInconsistency;
217 messenger,
"test",
nullptr,
nullptr,
218 [](GObject*
object, GAsyncResult* result, gpointer
user_data) {
219 g_autoptr(GError)
error =
nullptr;
221 FL_BINARY_MESSENGER(
object), result, &
error);
222 EXPECT_EQ(message,
nullptr);
223 EXPECT_NE(
error,
nullptr);
224 EXPECT_STREQ(
error->message,
"Failed to send platform messages");
226 g_main_loop_quit(
static_cast<GMainLoop*
>(
user_data));
230 g_main_loop_run(loop);
234 TEST(FlBinaryMessengerTest, Receive) {
238 g_autoptr(GError)
error =
nullptr;
240 EXPECT_EQ(
error,
nullptr);
245 SendPlatformMessageResponse,
246 ([&called](
auto engine,
247 const FlutterPlatformMessageResponseHandle* handle,
248 const uint8_t* data,
size_t data_length) {
251 int fake_handle = *
reinterpret_cast<const int*
>(handle);
252 EXPECT_EQ(fake_handle, 42);
254 g_autofree gchar* text =
255 g_strndup(
reinterpret_cast<const gchar*
>(data), data_length);
256 EXPECT_STREQ(text,
"Polo!");
266 [](FlBinaryMessenger* messenger,
const gchar* channel, GBytes* message,
267 FlBinaryMessengerResponseHandle* response_handle, gpointer
user_data) {
268 g_autofree gchar* text = g_strndup(
269 static_cast<const gchar*
>(g_bytes_get_data(message,
nullptr)),
270 g_bytes_get_size(message));
271 EXPECT_STREQ(text,
"Marco!");
273 const char* response_text =
"Polo!";
274 g_autoptr(GBytes) response =
275 g_bytes_new(response_text, strlen(response_text));
276 g_autoptr(GError)
error =
nullptr;
278 messenger, response_handle, response, &
error));
279 EXPECT_EQ(
error,
nullptr);
284 const char* message_text =
"Marco!";
285 g_autoptr(GBytes) message = g_bytes_new(message_text, strlen(message_text));
286 int fake_handle = 42;
288 messenger,
"test", message,
289 reinterpret_cast<const FlutterPlatformMessageResponseHandle*
>(
296 TEST(FlBinaryMessengerTest, ReceiveRespondThread) {
297 g_autoptr(GMainLoop) loop = g_main_loop_new(
nullptr, 0);
302 g_autoptr(GError)
error =
nullptr;
304 EXPECT_EQ(
error,
nullptr);
308 SendPlatformMessageResponse,
309 ([&loop](
auto engine,
310 const FlutterPlatformMessageResponseHandle* handle,
311 const uint8_t* data,
size_t data_length) {
312 int fake_handle = *
reinterpret_cast<const int*
>(handle);
313 EXPECT_EQ(fake_handle, 42);
315 g_autofree gchar* text =
316 g_strndup(
reinterpret_cast<const gchar*
>(data), data_length);
317 EXPECT_STREQ(text,
"Polo!");
319 g_main_loop_quit(loop);
329 [](FlBinaryMessenger* messenger,
const gchar* channel, GBytes* message,
330 FlBinaryMessengerResponseHandle* response_handle, gpointer
user_data) {
331 g_autofree gchar* text = g_strndup(
332 static_cast<const gchar*
>(g_bytes_get_data(message,
nullptr)),
333 g_bytes_get_size(message));
334 EXPECT_STREQ(text,
"Marco!");
338 FlBinaryMessenger* messenger;
339 FlBinaryMessengerResponseHandle* response_handle;
341 ThreadData* data = g_new0(ThreadData, 1);
343 static_cast<FlBinaryMessenger*
>(g_object_ref(messenger));
344 data->response_handle =
static_cast<FlBinaryMessengerResponseHandle*
>(
345 g_object_ref(response_handle));
346 g_autoptr(GThread) thread = g_thread_new(
349 g_autofree ThreadData* data =
static_cast<ThreadData*
>(
user_data);
350 g_autoptr(FlBinaryMessenger) messenger = data->messenger;
351 g_autoptr(FlBinaryMessengerResponseHandle) response_handle =
352 data->response_handle;
354 const char* response_text =
"Polo!";
355 g_autoptr(GBytes) response =
356 g_bytes_new(response_text, strlen(response_text));
357 g_autoptr(GError)
error =
nullptr;
359 data->messenger, data->response_handle, response, &
error));
360 EXPECT_EQ(
error,
nullptr);
362 return static_cast<gpointer
>(
nullptr);
369 const char* message_text =
"Marco!";
370 g_autoptr(GBytes) message = g_bytes_new(message_text, strlen(message_text));
371 int fake_handle = 42;
373 messenger,
"test", message,
374 reinterpret_cast<const FlutterPlatformMessageResponseHandle*
>(
377 g_main_loop_run(loop);
390 FlutterEngineSendPlatformMessageFnPtr old_handler =
394 ([&called, old_handler](
auto engine,
395 const FlutterPlatformMessage* message) {
397 if (strcmp(message->channel,
"dev.flutter/channel-buffers") != 0) {
398 return old_handler(engine, message);
406 const int expected_message_size = 29;
407 EXPECT_EQ(message->message_size,
408 static_cast<size_t>(expected_message_size));
409 int expected[expected_message_size] = {
410 7, 6, 114, 101, 115, 105, 122, 101, 12, 2,
411 7, 12, 102, 108, 117, 116, 116, 101, 114, 47,
412 116, 101, 115, 116, 3, 3, 0, 0, 0};
413 for (
size_t i = 0;
i < expected_message_size;
i++) {
414 EXPECT_EQ(message->message[
i], expected[
i]);
420 g_autoptr(GError)
error =
nullptr;
422 EXPECT_EQ(
error,
nullptr);
431 TEST(FlBinaryMessengerTest, WarnsOnOverflowChannel) {
437 FlutterEngineSendPlatformMessageFnPtr old_handler =
441 ([&called, old_handler](
auto engine,
442 const FlutterPlatformMessage* message) {
444 if (strcmp(message->channel,
"dev.flutter/channel-buffers") != 0) {
445 return old_handler(engine, message);
453 const int expected_message_size = 27;
454 EXPECT_EQ(message->message_size,
455 static_cast<size_t>(expected_message_size));
456 int expected[expected_message_size] = {
457 7, 8, 111, 118, 101, 114, 102, 108, 111, 119, 12, 2, 7, 12,
458 102, 108, 117, 116, 116, 101, 114, 47, 116, 101, 115, 116, 1};
459 for (
size_t i = 0;
i < expected_message_size;
i++) {
460 EXPECT_EQ(message->message[
i], expected[
i]);
466 g_autoptr(GError)
error =
nullptr;
468 EXPECT_EQ(
error,
nullptr);
479 TEST(FlBinaryMessengerTest, ControlChannelErrorResponse) {
480 g_autoptr(GMainLoop) loop = g_main_loop_new(
nullptr, 0);
485 g_autoptr(GError)
error =
nullptr;
487 EXPECT_EQ(
error,
nullptr);
491 FlutterEngineSendPlatformMessageFnPtr old_handler =
495 ([&called, old_handler, loop](
auto engine,
496 const FlutterPlatformMessage* message) {
498 if (strcmp(message->channel,
"dev.flutter/channel-buffers") != 0) {
499 return old_handler(engine, message);
508 g_main_loop_quit(
static_cast<GMainLoop*
>(
user_data));
514 return kInvalidArguments;
522 g_main_loop_run(loop);
527 TEST(FlBinaryMessengerTest, DeletingEngineClearsHandlers) {
531 g_autoptr(GError)
error =
nullptr;
533 EXPECT_EQ(
error,
nullptr);
538 gboolean destroy_notify_called = FALSE;
541 [](FlBinaryMessenger* messenger,
const gchar* channel, GBytes* message,
542 FlBinaryMessengerResponseHandle* response_handle,
544 &destroy_notify_called,
547 g_clear_object(&engine);
549 ASSERT_TRUE(destroy_notify_called);