fl_binary_messenger_test.cc File Reference

#include "flutter/shell/platform/linux/testing/linux_test.h"
#include "gtest/gtest.h"
#include <pthread.h>
#include <cstring>
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
#include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_binary_messenger.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"

Go to the source code of this file.

Classes
class	FlBinaryMessengerTest

Functions
	TEST_F (FlBinaryMessengerTest, Send)
	TEST_F (FlBinaryMessengerTest, SendNullptr)
	TEST_F (FlBinaryMessengerTest, SendEmpty)
	TEST_F (FlBinaryMessengerTest, NullptrResponse)
	TEST_F (FlBinaryMessengerTest, SendFailure)
	TEST_F (FlBinaryMessengerTest, Receive)
	TEST_F (FlBinaryMessengerTest, ReceiveRespondThread)
	TEST_F (FlBinaryMessengerTest, ResizeChannel)
	TEST_F (FlBinaryMessengerTest, WarnsOnOverflowChannel)
	TEST_F (FlBinaryMessengerTest, ControlChannelErrorResponse)
	TEST_F (FlBinaryMessengerTest, DeletingEngineClearsHandlers)

Function Documentation

TEST_F() [1/11]

TEST_F	(	FlBinaryMessengerTest	,
		ControlChannelErrorResponse
	)

Definition at line 429 of file fl_binary_messenger_test.cc.

                                                           {
  StartEngine();
 
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  bool called = false;
  FlutterEngineSendPlatformMessageFnPtr old_handler =
      fl_engine_get_embedder_api(engine)->SendPlatformMessage;
  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called, old_handler, this](auto engine,
                                    const FlutterPlatformMessage* message) {
        // Expect to receive a message on the "control" channel.
        if (strcmp(message->channel, "dev.flutter/channel-buffers") != 0) {
          return old_handler(engine, message);
        }
 
        called = true;
 
        // Register a callback to quit the main loop when binary messenger work
        // ends.
        g_idle_add(
            [](gpointer user_data) {
              g_main_loop_quit(static_cast<GMainLoop*>(user_data));
              return G_SOURCE_REMOVE;
            },
            loop);
 
        // Simulates an internal error.
        return kInvalidArguments;
      }));
 
  fl_binary_messenger_set_warns_on_channel_overflow(messenger, "flutter/test",
                                                    false);
 
  EXPECT_TRUE(called);
 
  g_main_loop_run(loop);
}

References engine, fl_binary_messenger_new(), fl_binary_messenger_set_warns_on_channel_overflow(), fl_engine_get_embedder_api(), g_autoptr(), kInvalidArguments, message, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPlatformMessage, and user_data.

TEST_F() [2/11]

TEST_F	(	FlBinaryMessengerTest	,
		DeletingEngineClearsHandlers
	)

Definition at line 470 of file fl_binary_messenger_test.cc.

                                                            {
  StartEngine();
 
  FlBinaryMessenger* messenger = fl_engine_get_binary_messenger(engine);
 
  // Add handler to check the destroy_notify is called.
  gboolean destroy_notify_called = FALSE;
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test",
      [](FlBinaryMessenger* messenger, const gchar* channel, GBytes* message,
         FlBinaryMessengerResponseHandle* response_handle,
         gpointer user_data) {},
      &destroy_notify_called,
      [](gpointer user_data) { *static_cast<gboolean*>(user_data) = TRUE; });
 
  g_clear_object(&engine);
 
  ASSERT_TRUE(destroy_notify_called);
}

References channel, engine, fl_binary_messenger_set_message_handler_on_channel(), fl_engine_get_binary_messenger(), message, TRUE, and user_data.

TEST_F() [3/11]

TEST_F	(	FlBinaryMessengerTest	,
		NullptrResponse
	)

Definition at line 125 of file fl_binary_messenger_test.cc.

                                               {
  StartEngine();
 
  FlutterDataCallback response_callback;
  void* response_callback_user_data;
  fl_engine_get_embedder_api(engine)->PlatformMessageCreateResponseHandle =
      MOCK_ENGINE_PROC(
          PlatformMessageCreateResponseHandle,
          ([&response_callback, &response_callback_user_data](
               auto engine, FlutterDataCallback data_callback, void* user_data,
               FlutterPlatformMessageResponseHandle** response_out) {
            response_callback = data_callback;
            response_callback_user_data = user_data;
            return kSuccess;
          }));
  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&response_callback, &response_callback_user_data](
           auto engine, const FlutterPlatformMessage* message) {
        EXPECT_STREQ(message->channel, "test");
        g_autofree gchar* text =
            g_strndup(reinterpret_cast<const gchar*>(message->message),
                      message->message_size);
        EXPECT_STREQ(text, "Hello World!");
 
        response_callback(nullptr, 0, response_callback_user_data);
 
        return kSuccess;
      }));
 
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  const char* text = "Hello World!";
  g_autoptr(GBytes) message = g_bytes_new(text, strlen(text));
  fl_binary_messenger_send_on_channel(
      messenger, "test", message, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(GBytes) message = fl_binary_messenger_send_on_channel_finish(
            FL_BINARY_MESSENGER(object), result, &error);
        EXPECT_NE(message, nullptr);
        EXPECT_EQ(error, nullptr);
 
        EXPECT_EQ(g_bytes_get_size(message), static_cast<gsize>(0));
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References engine, error, fl_binary_messenger_new(), fl_binary_messenger_send_on_channel(), fl_binary_messenger_send_on_channel_finish(), fl_engine_get_embedder_api(), g_autoptr(), kSuccess, message, MOCK_ENGINE_PROC, FlutterEngineProcTable::PlatformMessageCreateResponseHandle, FlutterEngineProcTable::SendPlatformMessage, text, and user_data.

TEST_F() [4/11]

TEST_F	(	FlBinaryMessengerTest	,
		Receive
	)

Definition at line 206 of file fl_binary_messenger_test.cc.

                                       {
  StartEngine();
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->SendPlatformMessageResponse =
      MOCK_ENGINE_PROC(
          SendPlatformMessageResponse,
          ([&called](auto engine,
                     const FlutterPlatformMessageResponseHandle* handle,
                     const uint8_t* data, size_t data_length) {
            called = true;
 
            int fake_handle = *reinterpret_cast<const int*>(handle);
            EXPECT_EQ(fake_handle, 42);
 
            g_autofree gchar* text =
                g_strndup(reinterpret_cast<const gchar*>(data), data_length);
            EXPECT_STREQ(text, "Polo!");
 
            return kSuccess;
          }));
 
  FlBinaryMessenger* messenger = fl_engine_get_binary_messenger(engine);
 
  // Listen for message.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test",
      [](FlBinaryMessenger* messenger, const gchar* channel, GBytes* message,
         FlBinaryMessengerResponseHandle* response_handle, gpointer user_data) {
        g_autofree gchar* text = g_strndup(
            static_cast<const gchar*>(g_bytes_get_data(message, nullptr)),
            g_bytes_get_size(message));
        EXPECT_STREQ(text, "Marco!");
 
        const char* response_text = "Polo!";
        g_autoptr(GBytes) response =
            g_bytes_new(response_text, strlen(response_text));
        g_autoptr(GError) error = nullptr;
        EXPECT_TRUE(fl_binary_messenger_send_response(
            messenger, response_handle, response, &error));
        EXPECT_EQ(error, nullptr);
      },
      nullptr, nullptr);
 
  // Send message from engine.
  const char* message_text = "Marco!";
  g_autoptr(GBytes) message = g_bytes_new(message_text, strlen(message_text));
  int fake_handle = 42;
  fl_binary_messenger_handle_message(
      messenger, "test", message,
      reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(
          &fake_handle));
 
  EXPECT_TRUE(called);
}

References channel, engine, error, fl_binary_messenger_handle_message(), fl_binary_messenger_send_response(), fl_binary_messenger_set_message_handler_on_channel(), fl_engine_get_binary_messenger(), fl_engine_get_embedder_api(), g_autoptr(), kSuccess, message, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPlatformMessageResponse, text, and user_data.

TEST_F() [5/11]

TEST_F	(	FlBinaryMessengerTest	,
		ReceiveRespondThread
	)

Definition at line 263 of file fl_binary_messenger_test.cc.

                                                    {
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendPlatformMessageResponse =
      MOCK_ENGINE_PROC(
          SendPlatformMessageResponse,
          ([this](auto engine,
                  const FlutterPlatformMessageResponseHandle* handle,
                  const uint8_t* data, size_t data_length) {
            int fake_handle = *reinterpret_cast<const int*>(handle);
            EXPECT_EQ(fake_handle, 42);
 
            g_autofree gchar* text =
                g_strndup(reinterpret_cast<const gchar*>(data), data_length);
            EXPECT_STREQ(text, "Polo!");
 
            g_main_loop_quit(loop);
 
            return kSuccess;
          }));
 
  FlBinaryMessenger* messenger = fl_engine_get_binary_messenger(engine);
 
  // Listen for message.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test",
      [](FlBinaryMessenger* messenger, const gchar* channel, GBytes* message,
         FlBinaryMessengerResponseHandle* response_handle, gpointer user_data) {
        g_autofree gchar* text = g_strndup(
            static_cast<const gchar*>(g_bytes_get_data(message, nullptr)),
            g_bytes_get_size(message));
        EXPECT_STREQ(text, "Marco!");
 
        // Respond on a thread.
        typedef struct {
          FlBinaryMessenger* messenger;
          FlBinaryMessengerResponseHandle* response_handle;
        } ThreadData;
        ThreadData* data = g_new0(ThreadData, 1);
        data->messenger =
            static_cast<FlBinaryMessenger*>(g_object_ref(messenger));
        data->response_handle = static_cast<FlBinaryMessengerResponseHandle*>(
            g_object_ref(response_handle));
        g_autoptr(GThread) thread = g_thread_new(
            nullptr,
            [](gpointer user_data) {
              g_autofree ThreadData* data = static_cast<ThreadData*>(user_data);
              g_autoptr(FlBinaryMessenger) messenger = data->messenger;
              g_autoptr(FlBinaryMessengerResponseHandle) response_handle =
                  data->response_handle;
 
              const char* response_text = "Polo!";
              g_autoptr(GBytes) response =
                  g_bytes_new(response_text, strlen(response_text));
              g_autoptr(GError) error = nullptr;
              EXPECT_TRUE(fl_binary_messenger_send_response(
                  data->messenger, data->response_handle, response, &error));
              EXPECT_EQ(error, nullptr);
 
              return static_cast<gpointer>(nullptr);
            },
            data);
      },
      nullptr, nullptr);
 
  // Send message from engine.
  const char* message_text = "Marco!";
  g_autoptr(GBytes) message = g_bytes_new(message_text, strlen(message_text));
  int fake_handle = 42;
  fl_binary_messenger_handle_message(
      messenger, "test", message,
      reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(
          &fake_handle));
 
  g_main_loop_run(loop);
}

References channel, engine, error, fl_binary_messenger_handle_message(), fl_binary_messenger_send_response(), fl_binary_messenger_set_message_handler_on_channel(), fl_engine_get_binary_messenger(), fl_engine_get_embedder_api(), g_autoptr(), kSuccess, message, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPlatformMessageResponse, text, and user_data.

TEST_F() [6/11]

TEST_F	(	FlBinaryMessengerTest	,
		ResizeChannel
	)

Definition at line 344 of file fl_binary_messenger_test.cc.

                                             {
  bool called = false;
 
  FlutterEngineSendPlatformMessageFnPtr old_handler =
      fl_engine_get_embedder_api(engine)->SendPlatformMessage;
  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called, old_handler](auto engine,
                              const FlutterPlatformMessage* message) {
        // Expect to receive a message on the "control" channel.
        if (strcmp(message->channel, "dev.flutter/channel-buffers") != 0) {
          return old_handler(engine, message);
        }
 
        called = true;
 
        // The expected content was created from the following Dart code:
        //   MethodCall call = MethodCall('resize', ['flutter/test',3]);
        //   StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
        const int expected_message_size = 29;
        EXPECT_EQ(message->message_size,
                  static_cast<size_t>(expected_message_size));
        int expected[expected_message_size] = {
            7,   6,   114, 101, 115, 105, 122, 101, 12,  2,
            7,   12,  102, 108, 117, 116, 116, 101, 114, 47,
            116, 101, 115, 116, 3,   3,   0,   0,   0};
        for (size_t i = 0; i < expected_message_size; i++) {
          EXPECT_EQ(message->message[i], expected[i]);
        }
 
        return kSuccess;
      }));
 
  StartEngine();
 
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  fl_binary_messenger_resize_channel(messenger, "flutter/test", 3);
 
  EXPECT_TRUE(called);
}

References engine, fl_binary_messenger_new(), fl_binary_messenger_resize_channel(), fl_engine_get_embedder_api(), g_autoptr(), i, kSuccess, message, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPlatformMessage.

TEST_F() [7/11]

TEST_F	(	FlBinaryMessengerTest	,
		Send
	)

Definition at line 22 of file fl_binary_messenger_test.cc.

                                    {
  StartEngine();
 
  FlutterDataCallback response_callback;
  void* response_callback_user_data;
  fl_engine_get_embedder_api(engine)->PlatformMessageCreateResponseHandle =
      MOCK_ENGINE_PROC(
          PlatformMessageCreateResponseHandle,
          ([&response_callback, &response_callback_user_data](
               auto engine, FlutterDataCallback data_callback, void* user_data,
               FlutterPlatformMessageResponseHandle** response_out) {
            response_callback = data_callback;
            response_callback_user_data = user_data;
            return kSuccess;
          }));
  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&response_callback, &response_callback_user_data](
           auto engine, const FlutterPlatformMessage* message) {
        EXPECT_STREQ(message->channel, "test");
        g_autofree gchar* text =
            g_strndup(reinterpret_cast<const gchar*>(message->message),
                      message->message_size);
        EXPECT_STREQ(text, "Marco!");
 
        const gchar* response = "Polo!";
        response_callback(reinterpret_cast<const uint8_t*>(response),
                          strlen(response), response_callback_user_data);
 
        return kSuccess;
      }));
 
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  const char* text = "Marco!";
  g_autoptr(GBytes) message = g_bytes_new(text, strlen(text));
  fl_binary_messenger_send_on_channel(
      messenger, "test", message, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(GBytes) message = fl_binary_messenger_send_on_channel_finish(
            FL_BINARY_MESSENGER(object), result, &error);
        EXPECT_NE(message, nullptr);
        EXPECT_EQ(error, nullptr);
 
        g_autofree gchar* text = g_strndup(
            static_cast<const gchar*>(g_bytes_get_data(message, nullptr)),
            g_bytes_get_size(message));
        EXPECT_STREQ(text, "Polo!");
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References engine, error, fl_binary_messenger_new(), fl_binary_messenger_send_on_channel(), fl_binary_messenger_send_on_channel_finish(), fl_engine_get_embedder_api(), g_autoptr(), kSuccess, message, MOCK_ENGINE_PROC, FlutterEngineProcTable::PlatformMessageCreateResponseHandle, FlutterEngineProcTable::SendPlatformMessage, text, and user_data.

TEST_F() [8/11]

TEST_F	(	FlBinaryMessengerTest	,
		SendEmpty
	)

Definition at line 103 of file fl_binary_messenger_test.cc.

                                         {
  StartEngine();
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called](auto engine, const FlutterPlatformMessage* message) {
        called = true;
 
        EXPECT_STREQ(message->channel, "test");
        EXPECT_EQ(message->message_size, static_cast<size_t>(0));
 
        return kSuccess;
      }));
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(GBytes) message = g_bytes_new(nullptr, 0);
  fl_binary_messenger_send_on_channel(messenger, "test", message, nullptr,
                                      nullptr, nullptr);
  EXPECT_TRUE(called);
}

References engine, fl_binary_messenger_new(), fl_binary_messenger_send_on_channel(), fl_engine_get_embedder_api(), g_autoptr(), kSuccess, message, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPlatformMessage.

TEST_F() [9/11]

TEST_F	(	FlBinaryMessengerTest	,
		SendFailure
	)

Definition at line 177 of file fl_binary_messenger_test.cc.

                                           {
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendPlatformMessage =
      MOCK_ENGINE_PROC(SendPlatformMessage,
                       ([](auto engine, const FlutterPlatformMessage* message) {
                         EXPECT_STREQ(message->channel, "test");
                         return kInternalInconsistency;
                       }));
 
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  fl_binary_messenger_send_on_channel(
      messenger, "test", nullptr, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(GBytes) message = fl_binary_messenger_send_on_channel_finish(
            FL_BINARY_MESSENGER(object), result, &error);
        EXPECT_EQ(message, nullptr);
        EXPECT_NE(error, nullptr);
        EXPECT_STREQ(error->message, "Failed to send platform messages");
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References engine, error, fl_binary_messenger_new(), fl_binary_messenger_send_on_channel(), fl_binary_messenger_send_on_channel_finish(), fl_engine_get_embedder_api(), g_autoptr(), kInternalInconsistency, message, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPlatformMessage, and user_data.

TEST_F() [10/11]

TEST_F	(	FlBinaryMessengerTest	,
		SendNullptr
	)

Definition at line 79 of file fl_binary_messenger_test.cc.

                                           {
  StartEngine();
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called](auto engine, const FlutterPlatformMessage* message) {
        called = true;
 
        EXPECT_STREQ(message->channel, "test");
        // Note we don't check message->message as it could be nullptr or a
        // pointer to an buffer - either way it wouldn't be accessed.
        EXPECT_EQ(message->message_size, static_cast<size_t>(0));
 
        return kSuccess;
      }));
 
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  fl_binary_messenger_send_on_channel(messenger, "test", nullptr, nullptr,
                                      nullptr, nullptr);
  EXPECT_TRUE(called);
}

References engine, fl_binary_messenger_new(), fl_binary_messenger_send_on_channel(), fl_engine_get_embedder_api(), g_autoptr(), kSuccess, message, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPlatformMessage.

TEST_F() [11/11]

TEST_F	(	FlBinaryMessengerTest	,
		WarnsOnOverflowChannel
	)

Definition at line 386 of file fl_binary_messenger_test.cc.

                                                      {
  bool called = false;
 
  FlutterEngineSendPlatformMessageFnPtr old_handler =
      fl_engine_get_embedder_api(engine)->SendPlatformMessage;
  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called, old_handler](auto engine,
                              const FlutterPlatformMessage* message) {
        // Expect to receive a message on the "control" channel.
        if (strcmp(message->channel, "dev.flutter/channel-buffers") != 0) {
          return old_handler(engine, message);
        }
 
        called = true;
 
        // The expected content was created from the following Dart code:
        //   MethodCall call = MethodCall('overflow',['flutter/test', true]);
        //   StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
        const int expected_message_size = 27;
        EXPECT_EQ(message->message_size,
                  static_cast<size_t>(expected_message_size));
        int expected[expected_message_size] = {
            7,   8,   111, 118, 101, 114, 102, 108, 111, 119, 12,  2,   7, 12,
            102, 108, 117, 116, 116, 101, 114, 47,  116, 101, 115, 116, 1};
        for (size_t i = 0; i < expected_message_size; i++) {
          EXPECT_EQ(message->message[i], expected[i]);
        }
 
        return kSuccess;
      }));
 
  StartEngine();
 
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  fl_binary_messenger_set_warns_on_channel_overflow(messenger, "flutter/test",
                                                    false);
 
  EXPECT_TRUE(called);
}

References engine, fl_binary_messenger_new(), fl_binary_messenger_set_warns_on_channel_overflow(), fl_engine_get_embedder_api(), g_autoptr(), i, kSuccess, message, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPlatformMessage.