Flutter Linux Embedder
Classes | Functions
fl_basic_message_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_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.

Classes

class  FlBasicMessageChannelTest
 

Functions

 TEST_F (FlBasicMessageChannelTest, SendMessageWithoutResponse)
 
 TEST_F (FlBasicMessageChannelTest, SendMessageWithResponse)
 
 TEST_F (FlBasicMessageChannelTest, SendFailure)
 
 TEST_F (FlBasicMessageChannelTest, ReceiveMessage)
 
 TEST_F (FlBasicMessageChannelTest, SendNullMessageWithResponse)
 
 TEST_F (FlBasicMessageChannelTest, CustomType)
 

Function Documentation

◆ TEST_F() [1/6]

TEST_F ( FlBasicMessageChannelTest  ,
CustomType   
)

Definition at line 191 of file fl_basic_message_channel_test.cc.

191  {
192  fl_mock_binary_messenger_set_standard_message_channel(
193  messenger, "test",
194  [](FlMockBinaryMessenger* messenger, GTask* task, FlValue* message,
195  gpointer user_data) { return fl_value_new_null(); },
196  nullptr);
197 
198  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
199  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
200  FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
201  g_autoptr(FlValue) message = fl_value_new_custom(42, nullptr, nullptr);
202  fl_basic_message_channel_send(
203  channel, message, nullptr,
204  [](GObject* object, GAsyncResult* result, gpointer user_data) {
205  g_autoptr(GError) error = nullptr;
206  g_autoptr(FlValue) message = fl_basic_message_channel_send_finish(
207  FL_BASIC_MESSAGE_CHANNEL(object), result, &error);
208  EXPECT_EQ(message, nullptr);
209  EXPECT_NE(error, nullptr);
210  EXPECT_STREQ(error->message, "Custom value not implemented");
211 
212  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
213  },
214  loop);
215 
216  g_main_loop_run(loop);
217 }
message
const char * message
Definition: fl_accessibility_handler.cc:21
g_autoptr
g_autoptr(FlEngine) engine
user_data
const char FlTextDirection FlAssertiveness gpointer user_data
Definition: fl_accessibility_handler.cc:24
fl_basic_message_channel_send_finish
G_MODULE_EXPORT FlValue * fl_basic_message_channel_send_finish(FlBasicMessageChannel *self, GAsyncResult *result, GError **error)
Definition: fl_basic_message_channel.cc:253
fl_basic_message_channel_new
G_MODULE_EXPORT FlBasicMessageChannel * fl_basic_message_channel_new(FlBinaryMessenger *messenger, const gchar *name, FlMessageCodec *codec)
Definition: fl_basic_message_channel.cc:154
fl_basic_message_channel_send
G_MODULE_EXPORT void fl_basic_message_channel_send(FlBasicMessageChannel *self, FlValue *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_basic_message_channel.cc:226
error
const uint8_t uint32_t uint32_t GError ** error
Definition: fl_pixel_buffer_texture_test.cc:41
fl_standard_message_codec_new
G_MODULE_EXPORT FlStandardMessageCodec * fl_standard_message_codec_new()
Definition: fl_standard_message_codec.cc:637
fl_value_new_custom
G_MODULE_EXPORT FlValue * fl_value_new_custom(int type, gconstpointer value, GDestroyNotify destroy_notify)
Definition: fl_value.cc:374
fl_value_new_null
G_MODULE_EXPORT FlValue * fl_value_new_null()
Definition: fl_value.cc:251
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42

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

◆ TEST_F() [2/6]

TEST_F ( FlBasicMessageChannelTest  ,
ReceiveMessage   
)

Definition at line 119 of file fl_basic_message_channel_test.cc.

119  {
120  // Listen for messages from the engine.
121  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
122  g_autoptr(FlBasicMessageChannel) messages_channel =
123  fl_basic_message_channel_new(FL_BINARY_MESSENGER(messenger), "test",
124  FL_MESSAGE_CODEC(codec));
125  fl_basic_message_channel_set_message_handler(
126  messages_channel,
127  [](FlBasicMessageChannel* channel, FlValue* message,
128  FlBasicMessageChannelResponseHandle* response_handle,
129  gpointer user_data) {
130  EXPECT_NE(message, nullptr);
131  EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_STRING);
132  EXPECT_STREQ(fl_value_get_string(message), "Marco!");
133 
134  g_autoptr(GError) error = nullptr;
135  g_autoptr(FlValue) response = fl_value_new_string("Polo!");
136  EXPECT_TRUE(fl_basic_message_channel_respond(channel, response_handle,
137  response, &error));
138  EXPECT_EQ(error, nullptr);
139  },
140  nullptr, nullptr);
141 
142  // Trigger the engine to send a message.
143  g_autoptr(FlValue) message = fl_value_new_string("Marco!");
144  gboolean called = FALSE;
145  fl_mock_binary_messenger_send_standard_message(
146  messenger, "test", message,
147  [](FlMockBinaryMessenger* messenger, FlValue* response,
148  gpointer user_data) {
149  gboolean* called = static_cast<gboolean*>(user_data);
150  *called = TRUE;
151 
152  EXPECT_NE(response, nullptr);
153  EXPECT_EQ(fl_value_get_type(response), FL_VALUE_TYPE_STRING);
154  EXPECT_STREQ(fl_value_get_string(response), "Polo!");
155  },
156  &called);
157 
158  EXPECT_TRUE(called);
159 }
fl_basic_message_channel_set_message_handler
G_MODULE_EXPORT void fl_basic_message_channel_set_message_handler(FlBasicMessageChannel *self, FlBasicMessageChannelMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
Definition: fl_basic_message_channel.cc:176
fl_basic_message_channel_respond
G_MODULE_EXPORT gboolean fl_basic_message_channel_respond(FlBasicMessageChannel *self, FlBasicMessageChannelResponseHandle *response_handle, FlValue *message, GError **error)
Definition: fl_basic_message_channel.cc:204
TRUE
return TRUE
Definition: fl_compositor_software.cc:68
fl_value_new_string
G_MODULE_EXPORT FlValue * fl_value_new_string(const gchar *value)
Definition: fl_value.cc:276
fl_value_get_type
G_MODULE_EXPORT FlValueType fl_value_get_type(FlValue *self)
Definition: fl_value.cc:466
fl_value_get_string
G_MODULE_EXPORT const gchar * fl_value_get_string(FlValue *self)
Definition: fl_value.cc:682
FL_VALUE_TYPE_STRING
@ FL_VALUE_TYPE_STRING
Definition: fl_value.h:68

References error, fl_basic_message_channel_new(), fl_basic_message_channel_respond(), fl_basic_message_channel_set_message_handler(), 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_F() [3/6]

TEST_F ( FlBasicMessageChannelTest  ,
SendFailure   
)

Definition at line 93 of file fl_basic_message_channel_test.cc.

93  {
94  fl_mock_binary_messenger_set_error_channel(messenger, "test", 42, "Error");
95 
96  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
97  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
98  FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
99  g_autoptr(FlValue) message = fl_value_new_string("Hello World!");
100  fl_basic_message_channel_send(
101  channel, message, nullptr,
102  [](GObject* object, GAsyncResult* result, gpointer user_data) {
103  g_autoptr(GError) error = nullptr;
104  g_autoptr(FlValue) message = fl_basic_message_channel_send_finish(
105  FL_BASIC_MESSAGE_CHANNEL(object), result, &error);
106  EXPECT_EQ(message, nullptr);
107  EXPECT_NE(error, nullptr);
108  EXPECT_EQ(error->code, 42);
109  EXPECT_STREQ(error->message, "Error");
110 
111  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
112  },
113  loop);
114 
115  g_main_loop_run(loop);
116 }

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

◆ TEST_F() [4/6]

TEST_F ( FlBasicMessageChannelTest  ,
SendMessageWithoutResponse   
)

Definition at line 27 of file fl_basic_message_channel_test.cc.

27  {
28  gboolean called = FALSE;
29  fl_mock_binary_messenger_set_standard_message_channel(
30  messenger, "test",
31  [](FlMockBinaryMessenger* messenger, GTask* task, FlValue* message,
32  gpointer user_data) {
33  gboolean* called = static_cast<gboolean*>(user_data);
34  *called = TRUE;
35 
36  EXPECT_NE(message, nullptr);
37  EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_STRING);
38  EXPECT_STREQ(fl_value_get_string(message), "Marco!");
39 
40  // No response.
41  return static_cast<FlValue*>(nullptr);
42  },
43  &called);
44 
45  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
46  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
47  FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
48  g_autoptr(FlValue) message = fl_value_new_string("Marco!");
49  fl_basic_message_channel_send(channel, message, nullptr, nullptr, nullptr);
50 
51  EXPECT_TRUE(called);
52 }

References fl_basic_message_channel_new(), fl_basic_message_channel_send(), 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_F() [5/6]

TEST_F ( FlBasicMessageChannelTest  ,
SendMessageWithResponse   
)

Definition at line 56 of file fl_basic_message_channel_test.cc.

56  {
57  fl_mock_binary_messenger_set_standard_message_channel(
58  messenger, "test",
59  [](FlMockBinaryMessenger* messenger, GTask* task, FlValue* message,
60  gpointer user_data) {
61  EXPECT_NE(message, nullptr);
62  EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_STRING);
63  EXPECT_STREQ(fl_value_get_string(message), "Marco!");
64 
65  return fl_value_new_string("Polo!");
66  },
67  nullptr);
68 
69  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
70  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
71  FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
72  g_autoptr(FlValue) message = fl_value_new_string("Marco!");
73  fl_basic_message_channel_send(
74  channel, message, nullptr,
75  [](GObject* object, GAsyncResult* result, gpointer user_data) {
76  g_autoptr(GError) error = nullptr;
77  g_autoptr(FlValue) message = fl_basic_message_channel_send_finish(
78  FL_BASIC_MESSAGE_CHANNEL(object), result, &error);
79  EXPECT_NE(message, nullptr);
80  EXPECT_EQ(error, nullptr);
81 
82  EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_STRING);
83  EXPECT_STREQ(fl_value_get_string(message), "Polo!");
84 
85  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
86  },
87  loop);
88 
89  g_main_loop_run(loop);
90 }

References error, fl_basic_message_channel_new(), fl_basic_message_channel_send(), fl_basic_message_channel_send_finish(), 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_F() [6/6]

TEST_F ( FlBasicMessageChannelTest  ,
SendNullMessageWithResponse   
)

Definition at line 162 of file fl_basic_message_channel_test.cc.

162  {
163  fl_mock_binary_messenger_set_standard_message_channel(
164  messenger, "test",
165  [](FlMockBinaryMessenger* messenger, GTask* task, FlValue* message,
166  gpointer user_data) { return fl_value_new_null(); },
167  nullptr);
168 
169  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
170  g_autoptr(FlBasicMessageChannel) channel = fl_basic_message_channel_new(
171  FL_BINARY_MESSENGER(messenger), "test", FL_MESSAGE_CODEC(codec));
172  fl_basic_message_channel_send(
173  channel, nullptr, nullptr,
174  [](GObject* object, GAsyncResult* result, gpointer user_data) {
175  g_autoptr(GError) error = nullptr;
176  g_autoptr(FlValue) message = fl_basic_message_channel_send_finish(
177  FL_BASIC_MESSAGE_CHANNEL(object), result, &error);
178  EXPECT_NE(message, nullptr);
179  EXPECT_EQ(error, nullptr);
180 
181  EXPECT_EQ(fl_value_get_type(message), FL_VALUE_TYPE_NULL);
182 
183  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
184  },
185  loop);
186 
187  g_main_loop_run(loop);
188 }
FL_VALUE_TYPE_NULL
@ FL_VALUE_TYPE_NULL
Definition: fl_value.h:64

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