fl_event_channel_test.cc File Reference

#include "gtest/gtest.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/fl_method_codec_private.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_basic_message_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_event_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_method_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"
#include "flutter/shell/platform/linux/testing/mock_renderer.h"

Go to the source code of this file.

Classes
struct	TestData

Functions
static FlEngine *	make_mock_engine ()
static void	listen_channel (FlBinaryMessenger *messenger, FlValue *args)
static void	cancel_channel (FlBinaryMessenger *messenger, FlValue *args)
static FlMethodErrorResponse *	listen_listen_cb (FlEventChannel *channel, FlValue *args, gpointer user_data)
	TEST (FlEventChannelTest, Listen)
static FlMethodErrorResponse *	listen_exception_listen_cb (FlEventChannel *channel, FlValue *args, gpointer user_data)
static void	listen_exception_response_cb (FlBinaryMessenger *messenger, const gchar *channel, GBytes *message, FlBinaryMessengerResponseHandle *response_handle, gpointer user_data)
	TEST (FlEventChannelTest, ListenException)
static FlMethodErrorResponse *	cancel_cancel_cb (FlEventChannel *channel, FlValue *args, gpointer user_data)
	TEST (FlEventChannelTest, Cancel)
static FlMethodErrorResponse *	cancel_exception_cancel_cb (FlEventChannel *channel, FlValue *args, gpointer user_data)
static void	cancel_exception_response_cb (FlBinaryMessenger *messenger, const gchar *channel, GBytes *message, FlBinaryMessengerResponseHandle *response_handle, gpointer user_data)
	TEST (FlEventChannelTest, CancelException)
static FlMethodErrorResponse *	args_listen_cb (FlEventChannel *channel, FlValue *args, gpointer user_data)
static FlMethodErrorResponse *	args_cancel_cb (FlEventChannel *channel, FlValue *args, gpointer user_data)
	TEST (FlEventChannelTest, Args)
static FlMethodErrorResponse *	send_events_listen_cb (FlEventChannel *channel, FlValue *args, gpointer user_data)
static void	send_events_events_cb (FlBinaryMessenger *messenger, const gchar *channel, GBytes *message, FlBinaryMessengerResponseHandle *response_handle, gpointer user_data)
	TEST (FlEventChannelTest, Test)
	TEST (FlEventChannelTest, ReuseChannel)
	TEST (FlEventChannelTest, ReplaceChannel)

Function Documentation

args_cancel_cb()

static FlMethodErrorResponse * args_cancel_cb ( FlEventChannel *  channel, FlValue *  args, gpointer  user_data  )

static

Definition at line 281 of file fl_event_channel_test.cc.

                                                                 {
  g_autoptr(FlValue) expected_args = fl_value_new_string("CANCEL-ARGS");
  EXPECT_TRUE(fl_value_equal(args, expected_args));
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
 
  return nullptr;
}

args_listen_cb()

static FlMethodErrorResponse * args_listen_cb ( FlEventChannel *  channel, FlValue *  args, gpointer  user_data  )

static

Definition at line 271 of file fl_event_channel_test.cc.

                                                                 {
  g_autoptr(FlValue) expected_args = fl_value_new_string("LISTEN-ARGS");
  EXPECT_TRUE(fl_value_equal(args, expected_args));
 
  return nullptr;
}

cancel_cancel_cb()

static FlMethodErrorResponse * cancel_cancel_cb ( FlEventChannel *  channel, FlValue *  args, gpointer  user_data  )

static

Definition at line 165 of file fl_event_channel_test.cc.

                                                                   {
  EXPECT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_NULL);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
 
  return nullptr;
}

cancel_channel()

static void cancel_channel ( FlBinaryMessenger *  messenger, FlValue *  args  )

static

Definition at line 53 of file fl_event_channel_test.cc.

                                                                        {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      messenger, "test/standard-method", FL_METHOD_CODEC(codec));
 
  // Trigger the engine to make a method call.
  g_autoptr(FlValue) invoke_args = fl_value_new_list();
  fl_value_append_take(invoke_args, fl_value_new_string("test/standard-event"));
  fl_value_append_take(invoke_args, fl_value_new_string("cancel"));
  g_autoptr(FlValue) value =
      args != nullptr ? fl_value_ref(args) : fl_value_new_null();
  fl_value_append(invoke_args, value);
  fl_method_channel_invoke_method(channel, "InvokeMethod", invoke_args, nullptr,
                                  nullptr, nullptr);
}

cancel_exception_cancel_cb()

static FlMethodErrorResponse * cancel_exception_cancel_cb ( FlEventChannel *  channel, FlValue *  args, gpointer  user_data  )

static

Definition at line 198 of file fl_event_channel_test.cc.

                        {
  return fl_method_error_response_new("CANCEL-ERROR", "CANCEL-ERROR-MESSAGE",
                                      nullptr);
}

cancel_exception_response_cb()

static void cancel_exception_response_cb ( FlBinaryMessenger *  messenger, const gchar *  channel, GBytes *  message, FlBinaryMessengerResponseHandle *  response_handle, gpointer  user_data  )

static

Definition at line 208 of file fl_event_channel_test.cc.

                        {
  TestData* data = static_cast<TestData*>(user_data);
 
  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
                                    nullptr);
 
  data->count++;
  if (data->count == 2) {
    g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
    g_autoptr(GError) error = nullptr;
    g_autoptr(FlMethodResponse) response = fl_method_codec_decode_response(
        FL_METHOD_CODEC(codec), message, &error);
    EXPECT_NE(response, nullptr);
    EXPECT_EQ(error, nullptr);
 
    EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
    EXPECT_STREQ(
        fl_method_error_response_get_code(FL_METHOD_ERROR_RESPONSE(response)),
        "CANCEL-ERROR");
    EXPECT_STREQ(fl_method_error_response_get_message(
                     FL_METHOD_ERROR_RESPONSE(response)),
                 "CANCEL-ERROR-MESSAGE");
 
    g_main_loop_quit(data->loop);
  }
}

listen_channel()

static void listen_channel ( FlBinaryMessenger *  messenger, FlValue *  args  )

static

Definition at line 36 of file fl_event_channel_test.cc.

                                                                        {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      messenger, "test/standard-method", FL_METHOD_CODEC(codec));
 
  // Trigger the engine to make a method call.
  g_autoptr(FlValue) invoke_args = fl_value_new_list();
  fl_value_append_take(invoke_args, fl_value_new_string("test/standard-event"));
  fl_value_append_take(invoke_args, fl_value_new_string("listen"));
  g_autoptr(FlValue) value =
      args != nullptr ? fl_value_ref(args) : fl_value_new_null();
  fl_value_append(invoke_args, value);
  fl_method_channel_invoke_method(channel, "InvokeMethod", invoke_args, nullptr,
                                  nullptr, nullptr);
}

listen_exception_listen_cb()

static FlMethodErrorResponse * listen_exception_listen_cb ( FlEventChannel *  channel, FlValue *  args, gpointer  user_data  )

static

Definition at line 102 of file fl_event_channel_test.cc.

                        {
  return fl_method_error_response_new("LISTEN-ERROR", "LISTEN-ERROR-MESSAGE",
                                      nullptr);
}

listen_exception_response_cb()

static void listen_exception_response_cb ( FlBinaryMessenger *  messenger, const gchar *  channel, GBytes *  message, FlBinaryMessengerResponseHandle *  response_handle, gpointer  user_data  )

static

Definition at line 112 of file fl_event_channel_test.cc.

                        {
  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
                                    nullptr);
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  EXPECT_NE(response, nullptr);
  EXPECT_EQ(error, nullptr);
 
  EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
  EXPECT_STREQ(
      fl_method_error_response_get_code(FL_METHOD_ERROR_RESPONSE(response)),
      "LISTEN-ERROR");
  EXPECT_STREQ(
      fl_method_error_response_get_message(FL_METHOD_ERROR_RESPONSE(response)),
      "LISTEN-ERROR-MESSAGE");
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

listen_listen_cb()

static FlMethodErrorResponse * listen_listen_cb ( FlEventChannel *  channel, FlValue *  args, gpointer  user_data  )

static

Definition at line 70 of file fl_event_channel_test.cc.

                                                                   {
  EXPECT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_NULL);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
 
  return nullptr;
}

make_mock_engine()

static FlEngine * make_mock_engine ( )

static

Definition at line 24 of file fl_event_channel_test.cc.

                                    {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlMockRenderer) renderer = fl_mock_renderer_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project, FL_RENDERER(renderer));
  g_autoptr(GError) engine_error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &engine_error));
  EXPECT_EQ(engine_error, nullptr);
 
  return static_cast<FlEngine*>(g_object_ref(engine));
}

send_events_events_cb()

static void send_events_events_cb ( FlBinaryMessenger *  messenger, const gchar *  channel, GBytes *  message, FlBinaryMessengerResponseHandle *  response_handle, gpointer  user_data  )

static

Definition at line 333 of file fl_event_channel_test.cc.

                        {
  TestData* data = static_cast<TestData*>(user_data);
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  EXPECT_NE(response, nullptr);
  EXPECT_EQ(error, nullptr);
 
  FlValue* result = fl_method_response_get_result(response, &error);
  EXPECT_NE(result, nullptr);
  EXPECT_EQ(error, nullptr);
 
  EXPECT_EQ(fl_value_get_type(result), FL_VALUE_TYPE_INT);
  EXPECT_EQ(fl_value_get_int(result), data->count);
  data->count++;
 
  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
                                    nullptr);
 
  // Got all the results!
  if (data->count == 5) {
    g_main_loop_quit(data->loop);
  }
}

send_events_listen_cb()

static FlMethodErrorResponse * send_events_listen_cb ( FlEventChannel *  channel, FlValue *  args, gpointer  user_data  )

static

Definition at line 317 of file fl_event_channel_test.cc.

                                                                        {
  // Send some events.
  for (int i = 0; i < 5; i++) {
    g_autoptr(FlValue) event = fl_value_new_int(i);
    g_autoptr(GError) error = nullptr;
    EXPECT_TRUE(fl_event_channel_send(channel, event, nullptr, &error));
    EXPECT_EQ(error, nullptr);
  }
 
  return nullptr;
}

TEST() [1/8]

TEST	(	FlEventChannelTest	,
		Args
	)

Definition at line 293 of file fl_event_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(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, args_listen_cb, args_cancel_cb,
                                       loop, nullptr);
 
  g_autoptr(FlValue) listen_args = fl_value_new_string("LISTEN-ARGS");
  listen_channel(messenger, listen_args);
  g_autoptr(FlValue) cancel_args = fl_value_new_string("CANCEL-ARGS");
  cancel_channel(messenger, cancel_args);
 
  // Blocks here until args_cancel_cb called.
  g_main_loop_run(loop);
 
  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

TEST() [2/8]

TEST	(	FlEventChannelTest	,
		Cancel
	)

Definition at line 176 of file fl_event_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(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, nullptr, cancel_cancel_cb, loop,
                                       nullptr);
 
  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);
 
  // Blocks here until cancel_cancel_cb called.
  g_main_loop_run(loop);
 
  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

TEST() [3/8]

TEST	(	FlEventChannelTest	,
		CancelException
	)

Definition at line 241 of file fl_event_channel_test.cc.

                                          {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
  TestData data;
  data.loop = loop;
  data.count = 0;
 
  g_autoptr(FlEngine) engine = make_mock_engine();
  FlBinaryMessenger* messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(
      channel, nullptr, cancel_exception_cancel_cb, &data, nullptr);
 
  // Listen for response to the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/responses", cancel_exception_response_cb, &data,
      nullptr);
 
  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);
 
  // Blocks here until cancel_exception_response_cb called.
  g_main_loop_run(loop);
 
  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

TEST() [4/8]

TEST	(	FlEventChannelTest	,
		Listen
	)

Definition at line 81 of file fl_event_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(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, listen_listen_cb, nullptr, loop,
                                       nullptr);
 
  listen_channel(messenger, nullptr);
 
  // Blocks here until listen_listen_cb called.
  g_main_loop_run(loop);
 
  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

TEST() [5/8]

TEST	(	FlEventChannelTest	,
		ListenException
	)

Definition at line 140 of file fl_event_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(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, listen_exception_listen_cb,
                                       nullptr, loop, nullptr);
 
  // Listen for response to the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/responses", listen_exception_response_cb, loop, nullptr);
 
  listen_channel(messenger, nullptr);
 
  // Blocks here until listen_exception_response_cb called.
  g_main_loop_run(loop);
 
  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}

TEST() [6/8]

TEST	(	FlEventChannelTest	,
		ReplaceChannel
	)

Definition at line 432 of file fl_event_channel_test.cc.

                                         {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
  TestData data;
  data.loop = loop;
  data.count = 0;
 
  // Register an event channel.
  g_autoptr(FlEngine) engine = make_mock_engine();
  FlBinaryMessenger* messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel1 = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel1, send_events_listen_cb, nullptr,
                                       &data, nullptr);
 
  // Register a second channel with the same name.
  g_autoptr(FlEventChannel) channel2 = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel2, send_events_listen_cb, nullptr,
                                       &data, nullptr);
 
  // Listen for events from the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/events", send_events_events_cb, &data, nullptr);
 
  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);
 
  // Blocks here until send_events_events_cb receives the last event.
  g_main_loop_run(loop);
}

TEST() [7/8]

TEST	(	FlEventChannelTest	,
		ReuseChannel
	)

Definition at line 396 of file fl_event_channel_test.cc.

                                       {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
  TestData data;
  data.loop = loop;
  data.count = 0;
 
  // Register an event channel.
  g_autoptr(FlEngine) engine = make_mock_engine();
  FlBinaryMessenger* messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel1 = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel1, send_events_listen_cb, nullptr,
                                       &data, nullptr);
 
  // Remove this channel
  g_object_unref(channel1);
 
  // Register a second channel with the same name.
  g_autoptr(FlEventChannel) channel2 = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel2, send_events_listen_cb, nullptr,
                                       &data, nullptr);
 
  // Listen for events from the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/events", send_events_events_cb, &data, nullptr);
 
  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);
 
  // Blocks here until send_events_events_cb receives the last event.
  g_main_loop_run(loop);
}

TEST() [8/8]

TEST	(	FlEventChannelTest	,
		Test
	)

Definition at line 366 of file fl_event_channel_test.cc.

                               {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
  TestData data;
  data.loop = loop;
  data.count = 0;
 
  g_autoptr(FlEngine) engine = make_mock_engine();
  FlBinaryMessenger* messenger = fl_binary_messenger_new(engine);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  FlEventChannel* channel = fl_event_channel_new(
      messenger, "test/standard-event", FL_METHOD_CODEC(codec));
  fl_event_channel_set_stream_handlers(channel, send_events_listen_cb, nullptr,
                                       &data, nullptr);
 
  // Listen for events from the engine.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test/events", send_events_events_cb, &data, nullptr);
 
  listen_channel(messenger, nullptr);
  cancel_channel(messenger, nullptr);
 
  // Blocks here until send_events_events_cb receives the last event.
  g_main_loop_run(loop);
 
  // Manually unref because the compiler complains 'channel' is unused.
  g_object_unref(channel);
}