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/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_mock_binary_messenger.h"

Go to the source code of this file.

Functions
	TEST (FlBasicMessageChannelTest, SendMessageWithoutResponse)
	TEST (FlBasicMessageChannelTest, SendMessageWithResponse)
	TEST (FlBasicMessageChannelTest, SendFailure)
	TEST (FlBasicMessageChannelTest, ReceiveMessage)
	TEST (FlBasicMessageChannelTest, SendNullMessageWithResponse)
	TEST (FlBasicMessageChannelTest, CustomType)

Function Documentation

TEST() [1/6]

TEST	(	FlBasicMessageChannelTest	,
		CustomType
	)

Definition at line 193 of file fl_basic_message_channel_test.cc.

                                            {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  fl_mock_binary_messenger_set_standard_message_channel(
      messenger, "test",
      [](FlMockBinaryMessenger* messenger, GTask* task, FlValue* message,
         gpointer user_data) { return fl_value_new_null(); },
      nullptr);
 
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
  g_autoptr(FlValue) message = fl_value_new_custom(42, nullptr, nullptr);
  fl_basic_message_channel_send(
      channel, message, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        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);
        EXPECT_STREQ(error->message, "Custom value not implemented");
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References channel, error, fl_basic_message_channel_new(), fl_basic_message_channel_send(), fl_basic_message_channel_send_finish(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_standard_message_channel(), fl_standard_message_codec_new(), fl_value_new_custom(), fl_value_new_null(), g_autoptr(), message, and user_data.

TEST() [2/6]

TEST	(	FlBasicMessageChannelTest	,
		ReceiveMessage
	)

Definition at line 116 of file fl_basic_message_channel_test.cc.

                                                {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
 
  // 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(FL_BINARY_MESSENGER(messenger), "test",
                                   FL_MESSAGE_CODEC(codec));
  fl_basic_message_channel_set_message_handler(
      messages_channel,
      [](FlBasicMessageChannel* channel, FlValue* message,
         FlBasicMessageChannelResponseHandle* response_handle,
         gpointer user_data) {
        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);
      },
      nullptr, nullptr);
 
  // Trigger the engine to send a message.
  g_autoptr(FlValue) message = fl_value_new_string("Marco!");
  gboolean called = FALSE;
  fl_mock_binary_messenger_send_standard_message(
      messenger, "test", message,
      [](FlMockBinaryMessenger* messenger, FlValue* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_NE(response, nullptr);
        EXPECT_EQ(fl_value_get_type(response), FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(response), "Polo!");
      },
      &called);
 
  EXPECT_TRUE(called);
}

References channel, error, fl_basic_message_channel_new(), fl_basic_message_channel_respond(), fl_basic_message_channel_set_message_handler(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_send_standard_message(), fl_standard_message_codec_new(), fl_value_get_string(), fl_value_get_type(), fl_value_new_string(), FL_VALUE_TYPE_STRING, g_autoptr(), message, TRUE, and user_data.

TEST() [3/6]

TEST	(	FlBasicMessageChannelTest	,
		SendFailure
	)

Definition at line 87 of file fl_basic_message_channel_test.cc.

                                             {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  fl_mock_binary_messenger_set_error_channel(messenger, "test", 42, "Error");
 
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
  g_autoptr(FlValue) message = fl_value_new_string("Hello World!");
  fl_basic_message_channel_send(
      channel, message, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        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);
        EXPECT_EQ(error->code, 42);
        EXPECT_STREQ(error->message, "Error");
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References channel, error, fl_basic_message_channel_new(), fl_basic_message_channel_send(), fl_basic_message_channel_send_finish(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_error_channel(), fl_standard_message_codec_new(), fl_value_new_string(), g_autoptr(), message, and user_data.

TEST() [4/6]

TEST	(	FlBasicMessageChannelTest	,
		SendMessageWithoutResponse
	)

Definition at line 17 of file fl_basic_message_channel_test.cc.

                                                            {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  gboolean called = FALSE;
  fl_mock_binary_messenger_set_standard_message_channel(
      messenger, "test",
      [](FlMockBinaryMessenger* messenger, GTask* task, FlValue* message,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_NE(message, nullptr);
        EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(message), "Marco!");
 
        // No response.
        return static_cast<FlValue*>(nullptr);
      },
      &called);
 
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
  g_autoptr(FlValue) message = fl_value_new_string("Marco!");
  fl_basic_message_channel_send(channel, message, nullptr, nullptr, nullptr);
 
  EXPECT_TRUE(called);
}

References channel, fl_basic_message_channel_new(), fl_basic_message_channel_send(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_standard_message_channel(), fl_standard_message_codec_new(), fl_value_get_string(), fl_value_get_type(), fl_value_new_string(), FL_VALUE_TYPE_STRING, g_autoptr(), message, TRUE, and user_data.

TEST() [5/6]

TEST	(	FlBasicMessageChannelTest	,
		SendMessageWithResponse
	)

Definition at line 47 of file fl_basic_message_channel_test.cc.

                                                         {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  fl_mock_binary_messenger_set_standard_message_channel(
      messenger, "test",
      [](FlMockBinaryMessenger* messenger, GTask* task, FlValue* message,
         gpointer user_data) {
        EXPECT_NE(message, nullptr);
        EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(message), "Marco!");
 
        return fl_value_new_string("Polo!");
      },
      nullptr);
 
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
  g_autoptr(FlValue) message = fl_value_new_string("Marco!");
  fl_basic_message_channel_send(
      channel, message, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        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), "Polo!");
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References channel, error, fl_basic_message_channel_new(), fl_basic_message_channel_send(), fl_basic_message_channel_send_finish(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_standard_message_channel(), fl_standard_message_codec_new(), fl_value_get_string(), fl_value_get_type(), fl_value_new_string(), FL_VALUE_TYPE_STRING, g_autoptr(), message, and user_data.

TEST() [6/6]

TEST	(	FlBasicMessageChannelTest	,
		SendNullMessageWithResponse
	)

Definition at line 161 of file fl_basic_message_channel_test.cc.

                                                             {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  fl_mock_binary_messenger_set_standard_message_channel(
      messenger, "test",
      [](FlMockBinaryMessenger* messenger, GTask* task, FlValue* message,
         gpointer user_data) { return fl_value_new_null(); },
      nullptr);
 
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
  fl_basic_message_channel_send(
      channel, nullptr, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        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));
      },
      loop);
 
  g_main_loop_run(loop);
}

References channel, error, fl_basic_message_channel_new(), fl_basic_message_channel_send(), fl_basic_message_channel_send_finish(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_standard_message_channel(), fl_standard_message_codec_new(), fl_value_get_type(), fl_value_new_null(), FL_VALUE_TYPE_NULL, g_autoptr(), message, and user_data.