fl_basic_message_channel_test.cc File Reference

#include "gtest/gtest.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_basic_message_channel.h"
#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_message_codec.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_message_codec.h"
#include "flutter/shell/platform/linux/testing/fl_test.h"
#include "flutter/shell/platform/linux/testing/mock_renderer.h"

Go to the source code of this file.

Functions
	TEST (FlBasicMessageChannelTest, SendMessageWithoutResponse)
static void	echo_response_cb (GObject *object, GAsyncResult *result, gpointer user_data)
	TEST (FlBasicMessageChannelTest, SendMessageWithResponse)
static void	failure_response_cb (GObject *object, GAsyncResult *result, gpointer user_data)
	TEST (FlBasicMessageChannelTest, SendFailure)
static void	message_cb (FlBasicMessageChannel *channel, FlValue *message, FlBasicMessageChannelResponseHandle *response_handle, gpointer user_data)
static void	response_cb (FlBasicMessageChannel *channel, FlValue *message, FlBasicMessageChannelResponseHandle *response_handle, gpointer user_data)
	TEST (FlBasicMessageChannelTest, ReceiveMessage)
static void	null_message_response_cb (GObject *object, GAsyncResult *result, gpointer user_data)
	TEST (FlBasicMessageChannelTest, SendNullMessageWithResponse)

Function Documentation

echo_response_cb()

static void echo_response_cb ( GObject *  object, GAsyncResult *  result, gpointer  user_data  )

static

Definition at line 67 of file fl_basic_message_channel_test.cc.

                                                 {
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlValue) message = fl_basic_message_channel_send_finish(
      FL_BASIC_MESSAGE_CHANNEL(object), result, &error);
  EXPECT_NE(message, nullptr);
  EXPECT_EQ(error, nullptr);
 
  EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_STRING);
  EXPECT_STREQ(fl_value_get_string(message), "Hello World!");
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

failure_response_cb()

static void failure_response_cb ( GObject *  object, GAsyncResult *  result, gpointer  user_data  )

static

Definition at line 100 of file fl_basic_message_channel_test.cc.

                                                    {
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlValue) message = fl_basic_message_channel_send_finish(
      FL_BASIC_MESSAGE_CHANNEL(object), result, &error);
  EXPECT_EQ(message, nullptr);
  EXPECT_NE(error, nullptr);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

message_cb()

static void message_cb ( FlBasicMessageChannel *  channel, FlValue *  message, FlBasicMessageChannelResponseHandle *  response_handle, gpointer  user_data  )

static

Definition at line 130 of file fl_basic_message_channel_test.cc.

                                           {
  EXPECT_NE(message, nullptr);
  EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_STRING);
  EXPECT_STREQ(fl_value_get_string(message), "Marco!");
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlValue) response = fl_value_new_string("Polo!");
  EXPECT_TRUE(fl_basic_message_channel_respond(channel, response_handle,
                                               response, &error));
  EXPECT_EQ(error, nullptr);
}

null_message_response_cb()

static void null_message_response_cb ( GObject *  object, GAsyncResult *  result, gpointer  user_data  )

static

Definition at line 196 of file fl_basic_message_channel_test.cc.

                                                         {
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlValue) message = fl_basic_message_channel_send_finish(
      FL_BASIC_MESSAGE_CHANNEL(object), result, &error);
  EXPECT_NE(message, nullptr);
  EXPECT_EQ(error, nullptr);
 
  EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_NULL);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

response_cb()

static void response_cb ( FlBasicMessageChannel *  channel, FlValue *  message, FlBasicMessageChannelResponseHandle *  response_handle, gpointer  user_data  )

static

Definition at line 147 of file fl_basic_message_channel_test.cc.

                                            {
  EXPECT_NE(message, nullptr);
  EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_STRING);
  EXPECT_STREQ(fl_value_get_string(message), "Polo!");
 
  fl_basic_message_channel_respond(channel, response_handle, nullptr, nullptr);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

TEST() [1/5]

TEST	(	FlBasicMessageChannelTest	,
		ReceiveMessage
	)

Definition at line 161 of file fl_basic_message_channel_test.cc.

                                                {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlEngine) engine = make_mock_engine();
  FlBinaryMessenger* messenger = fl_binary_messenger_new(engine);
 
  // Listen for messages from the engine.
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) messages_channel =
      fl_basic_message_channel_new(messenger, "test/messages",
                                   FL_MESSAGE_CODEC(codec));
  fl_basic_message_channel_set_message_handler(messages_channel, message_cb,
                                               nullptr, nullptr);
 
  // Listen for response from the engine.
  g_autoptr(FlBasicMessageChannel) responses_channel =
      fl_basic_message_channel_new(messenger, "test/responses",
                                   FL_MESSAGE_CODEC(codec));
  fl_basic_message_channel_set_message_handler(responses_channel, response_cb,
                                               loop, nullptr);
 
  // Triggger the engine to send a message.
  g_autoptr(FlBasicMessageChannel) control_channel =
      fl_basic_message_channel_new(messenger, "test/send-message",
                                   FL_MESSAGE_CODEC(codec));
  g_autoptr(FlValue) message = fl_value_new_string("Marco!");
  fl_basic_message_channel_send(control_channel, message, nullptr, nullptr,
                                nullptr);
 
  // Blocks here until response_cb is called.
  g_main_loop_run(loop);
}

TEST() [2/5]

TEST	(	FlBasicMessageChannelTest	,
		SendFailure
	)

Definition at line 113 of file fl_basic_message_channel_test.cc.

                                             {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlEngine) engine = make_mock_engine();
  FlBinaryMessenger* messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
      messenger, "test/failure", FL_MESSAGE_CODEC(codec));
  g_autoptr(FlValue) message = fl_value_new_string("Hello World!");
  fl_basic_message_channel_send(channel, message, nullptr, failure_response_cb,
                                loop);
 
  // Blocks here until failure_response_cb is called.
  g_main_loop_run(loop);
}

TEST() [3/5]

TEST	(	FlBasicMessageChannelTest	,
		SendMessageWithoutResponse
	)

Definition at line 22 of file fl_basic_message_channel_test.cc.

                                                            {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlEngine) engine = make_mock_engine();
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);
 
  bool called = false;
  FlutterEngineSendPlatformMessageFnPtr old_handler =
      embedder_api->SendPlatformMessage;
  embedder_api->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called, old_handler](auto engine,
                              const FlutterPlatformMessage* message) {
        if (strcmp(message->channel, "test") != 0) {
          return old_handler(engine, message);
        }
 
        called = true;
        EXPECT_EQ(message->response_handle, nullptr);
 
        g_autoptr(GBytes) message_bytes =
            g_bytes_new(message->message, message->message_size);
        g_autoptr(FlStandardMessageCodec) codec =
            fl_standard_message_codec_new();
        FlValue* message_value = fl_message_codec_decode_message(
            FL_MESSAGE_CODEC(codec), message_bytes, nullptr);
        EXPECT_EQ(fl_value_get_type(message_value), FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(message_value), "Hello World!");
 
        return kSuccess;
      }));
 
  FlBinaryMessenger* messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) channel =
      fl_basic_message_channel_new(messenger, "test", FL_MESSAGE_CODEC(codec));
  g_autoptr(FlValue) message = fl_value_new_string("Hello World!");
  fl_basic_message_channel_send(channel, message, nullptr, nullptr, loop);
 
  EXPECT_TRUE(called);
}

TEST() [4/5]

TEST	(	FlBasicMessageChannelTest	,
		SendMessageWithResponse
	)

Definition at line 83 of file fl_basic_message_channel_test.cc.

                                                         {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlEngine) engine = make_mock_engine();
  FlBinaryMessenger* messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
      messenger, "test/echo", FL_MESSAGE_CODEC(codec));
  g_autoptr(FlValue) message = fl_value_new_string("Hello World!");
  fl_basic_message_channel_send(channel, message, nullptr, echo_response_cb,
                                loop);
 
  // Blocks here until echo_response_cb is called.
  g_main_loop_run(loop);
}

TEST() [5/5]

TEST	(	FlBasicMessageChannelTest	,
		SendNullMessageWithResponse
	)

Definition at line 211 of file fl_basic_message_channel_test.cc.

                                                             {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlEngine) engine = make_mock_engine();
  FlBinaryMessenger* messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
      messenger, "test/echo", FL_MESSAGE_CODEC(codec));
  fl_basic_message_channel_send(channel, nullptr, nullptr,
                                null_message_response_cb, loop);
 
  // Blocks here until null_message_response_cb is called.
  g_main_loop_run(loop);
}