#include "gtest/gtest.h"
#include "flutter/shell/platform/linux/fl_method_codec_private.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/fl_mock_binary_messenger.h"

Functions
	TEST (FlMethodChannelTest, InvokeMethod)

	TEST (FlMethodChannelTest, InvokeMethodNullptrArgsMessage)

	TEST (FlMethodChannelTest, InvokeMethodError)

	TEST (FlMethodChannelTest, InvokeMethodNotImplemented)

	TEST (FlMethodChannelTest, InvokeMethodFailure)

	TEST (FlMethodChannelTest, ReceiveMethodCallRespondSuccess)

	TEST (FlMethodChannelTest, ReceiveMethodCallRespondError)

	TEST (FlMethodChannelTest, ReceiveMethodCallRespondNotImplemented)

	G_DECLARE_FINAL_TYPE (TestMethodCodec, test_method_codec, TEST, METHOD_CODEC, FlMethodCodec) struct _TestMethodCodec

static void	test_method_codec_dispose (GObject *object)

static GBytes *	test_method_codec_encode_method_call (FlMethodCodec codec, const gchar name, FlValue args, GError *error)

static gboolean	test_method_codec_decode_method_call (FlMethodCodec codec, GBytes message, gchar name, FlValue args, GError **error)

static GBytes *	test_method_codec_encode_success_envelope (FlMethodCodec codec, FlValue result, GError **error)

static GBytes *	test_method_codec_encode_error_envelope (FlMethodCodec codec, const gchar code, const gchar message, FlValue details, GError **error)

static FlMethodResponse *	test_method_codec_decode_response (FlMethodCodec codec, GBytes message, GError **error)

static void	test_method_codec_class_init (TestMethodCodecClass *klass)

static void	test_method_codec_init (TestMethodCodec *self)

TestMethodCodec *	test_method_codec_new ()

	TEST (FlMethodChannelTest, ReceiveMethodCallRespondSuccessError)

	TEST (FlMethodChannelTest, ReceiveMethodCallRespondErrorError)

	TEST (FlMethodChannelTest, ReplaceADisposedMethodChannel)

	TEST (FlMethodChannelTest, DisposeAReplacedMethodChannel)

	TEST (FlMethodChannelTest, CustomType)

Function Documentation

◆ G_DECLARE_FINAL_TYPE()

G_DECLARE_FINAL_TYPE	(	TestMethodCodec	,
		test_method_codec	,
		TEST	,
		METHOD_CODEC	,
		FlMethodCodec
	)

Definition at line 355 of file fl_method_channel_test.cc.

                        {
  FlMethodCodec parent_instance;
 
  FlStandardMethodCodec* wrapped_codec;
};

◆ TEST() [1/13]

TEST	(	FlMethodChannelTest	,
		CustomType
	)

Definition at line 657 of file fl_method_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_method_channel(
      messenger, "test",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      nullptr);
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
 
  g_autoptr(FlValue) args = fl_value_new_custom(42, nullptr, nullptr);
  fl_method_channel_invoke_method(
      channel, "Test", args, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(FlMethodResponse) response =
            fl_method_channel_invoke_method_finish(FL_METHOD_CHANNEL(object),
                                                   result, &error);
        EXPECT_EQ(response, 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 args, channel, error, fl_method_channel_invoke_method(), fl_method_channel_invoke_method_finish(), fl_method_channel_new(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_standard_method_channel(), fl_standard_method_codec_new(), fl_value_new_custom(), g_autoptr(), name, and user_data.

◆ TEST() [2/13]

TEST	(	FlMethodChannelTest	,
		DisposeAReplacedMethodChannel
	)

Definition at line 592 of file fl_method_channel_test.cc.

                                                         {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
 
  // Register the first channel and test if it works.
  FlMethodChannel* channel1 = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
  int first_count = 0;
  fl_method_channel_set_method_call_handler(
      channel1,
      [](FlMethodChannel* channel, FlMethodCall* method_call,
         gpointer user_data) {
        int* first_count = static_cast<int*>(user_data);
        (*first_count)++;
 
        EXPECT_TRUE(
            fl_method_call_respond_success(method_call, nullptr, nullptr));
      },
      &first_count, nullptr);
 
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "test", "Test", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {},
      nullptr);
  EXPECT_EQ(first_count, 1);
 
  // Register a new channel to the same name.
  g_autoptr(FlMethodChannel) channel2 = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
  int second_count = 0;
  fl_method_channel_set_method_call_handler(
      channel2,
      [](FlMethodChannel* channel, FlMethodCall* method_call,
         gpointer user_data) {
        int* second_count = static_cast<int*>(user_data);
        (*second_count)++;
 
        EXPECT_TRUE(
            fl_method_call_respond_success(method_call, nullptr, nullptr));
      },
      &second_count, nullptr);
 
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "test", "Test", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {},
      nullptr);
  EXPECT_EQ(first_count, 1);
  EXPECT_EQ(second_count, 1);
 
  // Dispose the first channel. The new channel should keep working.
  g_object_unref(channel1);
 
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "test", "Test", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {},
      nullptr);
  EXPECT_EQ(first_count, 1);
  EXPECT_EQ(second_count, 2);
}

References channel, fl_method_call_respond_success(), fl_method_channel_new(), fl_method_channel_set_method_call_handler(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_new(), fl_standard_method_codec_new(), g_autoptr(), method_call, and user_data.

◆ TEST() [3/13]

TEST	(	FlMethodChannelTest	,
		InvokeMethod
	)

Definition at line 14 of file fl_method_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_method_channel(
      messenger, "test",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        EXPECT_STREQ(name, "Test");
        EXPECT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(args), "Marco!");
        g_autoptr(FlValue) return_value = fl_value_new_string("Polo!");
        return FL_METHOD_RESPONSE(fl_method_success_response_new(return_value));
      },
      nullptr);
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
 
  g_autoptr(FlValue) args = fl_value_new_string("Marco!");
  fl_method_channel_invoke_method(
      channel, "Test", args, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(FlMethodResponse) response =
            fl_method_channel_invoke_method_finish(FL_METHOD_CHANNEL(object),
                                                   result, &error);
        EXPECT_NE(response, nullptr);
        EXPECT_EQ(error, nullptr);
 
        FlValue* r = fl_method_response_get_result(response, &error);
        EXPECT_NE(r, nullptr);
        EXPECT_EQ(error, nullptr);
 
        EXPECT_EQ(fl_value_get_type(r), FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(r), "Polo!");
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References args, channel, error, fl_method_channel_invoke_method(), fl_method_channel_invoke_method_finish(), fl_method_channel_new(), fl_method_response_get_result(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_standard_method_channel(), fl_standard_method_codec_new(), fl_value_get_string(), fl_value_get_type(), fl_value_new_string(), FL_VALUE_TYPE_STRING, g_autoptr(), name, and user_data.

◆ TEST() [4/13]

TEST	(	FlMethodChannelTest	,
		InvokeMethodError
	)

Definition at line 101 of file fl_method_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_method_channel(
      messenger, "test",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        EXPECT_STREQ(name, "Test");
        g_autoptr(FlValue) details = fl_value_new_string("DETAILS");
        return FL_METHOD_RESPONSE(
            fl_method_error_response_new("CODE", "MESSAGE", details));
      },
      nullptr);
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
 
  fl_method_channel_invoke_method(
      channel, "Test", nullptr, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(FlMethodResponse) response =
            fl_method_channel_invoke_method_finish(FL_METHOD_CHANNEL(object),
                                                   result, &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)),
                     "CODE");
        EXPECT_STREQ(fl_method_error_response_get_message(
                         FL_METHOD_ERROR_RESPONSE(response)),
                     "MESSAGE");
        FlValue* details = fl_method_error_response_get_details(
            FL_METHOD_ERROR_RESPONSE(response));
        EXPECT_NE(details, nullptr);
        EXPECT_EQ(fl_value_get_type(details), FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(details), "DETAILS");
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References args, channel, error, fl_method_channel_invoke_method(), fl_method_channel_invoke_method_finish(), fl_method_channel_new(), fl_method_error_response_get_code(), fl_method_error_response_get_details(), fl_method_error_response_get_message(), fl_method_error_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_standard_method_channel(), fl_standard_method_codec_new(), fl_value_get_string(), fl_value_get_type(), fl_value_new_string(), FL_VALUE_TYPE_STRING, g_autoptr(), name, and user_data.

◆ TEST() [5/13]

TEST	(	FlMethodChannelTest	,
		InvokeMethodFailure
	)

Definition at line 188 of file fl_method_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(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
 
  fl_method_channel_invoke_method(
      channel, "Test", nullptr, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(FlMethodResponse) response =
            fl_method_channel_invoke_method_finish(FL_METHOD_CHANNEL(object),
                                                   result, &error);
        EXPECT_EQ(response, 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_method_channel_invoke_method(), fl_method_channel_invoke_method_finish(), fl_method_channel_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_error_channel(), fl_standard_method_codec_new(), g_autoptr(), and user_data.

◆ TEST() [6/13]

TEST	(	FlMethodChannelTest	,
		InvokeMethodNotImplemented
	)

Definition at line 151 of file fl_method_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_method_channel(
      messenger, "test",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        EXPECT_STREQ(name, "Test");
        return FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
      },
      nullptr);
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
 
  fl_method_channel_invoke_method(
      channel, "Test", nullptr, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(FlMethodResponse) response =
            fl_method_channel_invoke_method_finish(FL_METHOD_CHANNEL(object),
                                                   result, &error);
        EXPECT_NE(response, nullptr);
        EXPECT_EQ(error, nullptr);
 
        EXPECT_TRUE(FL_IS_METHOD_NOT_IMPLEMENTED_RESPONSE(response));
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References args, channel, error, fl_method_channel_invoke_method(), fl_method_channel_invoke_method_finish(), fl_method_channel_new(), fl_method_not_implemented_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_standard_method_channel(), fl_standard_method_codec_new(), g_autoptr(), name, and user_data.

◆ TEST() [7/13]

TEST	(	FlMethodChannelTest	,
		InvokeMethodNullptrArgsMessage
	)

Definition at line 60 of file fl_method_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_method_channel(
      messenger, "test",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        EXPECT_STREQ(name, "Test");
        EXPECT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_NULL);
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      nullptr);
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
 
  fl_method_channel_invoke_method(
      channel, "Test", nullptr, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(FlMethodResponse) response =
            fl_method_channel_invoke_method_finish(FL_METHOD_CHANNEL(object),
                                                   result, &error);
        EXPECT_NE(response, nullptr);
        EXPECT_EQ(error, nullptr);
 
        FlValue* r = fl_method_response_get_result(response, &error);
        EXPECT_NE(r, nullptr);
        EXPECT_EQ(error, nullptr);
        EXPECT_EQ(fl_value_get_type(r), FL_VALUE_TYPE_NULL);
 
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
}

References args, channel, error, fl_method_channel_invoke_method(), fl_method_channel_invoke_method_finish(), fl_method_channel_new(), fl_method_response_get_result(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_standard_method_channel(), fl_standard_method_codec_new(), fl_value_get_type(), FL_VALUE_TYPE_NULL, g_autoptr(), name, and user_data.

◆ TEST() [8/13]

TEST	(	FlMethodChannelTest	,
		ReceiveMethodCallRespondError
	)

Definition at line 264 of file fl_method_channel_test.cc.

                                                         {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
  fl_method_channel_set_method_call_handler(
      channel,
      [](FlMethodChannel* channel, FlMethodCall* method_call,
         gpointer user_data) {
        EXPECT_STREQ(fl_method_call_get_name(method_call), "Test");
        EXPECT_EQ(fl_value_get_type(fl_method_call_get_args(method_call)),
                  FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(fl_method_call_get_args(method_call)),
                     "Marco!");
 
        g_autoptr(FlValue) details = fl_value_new_string("DETAILS");
        g_autoptr(GError) error = nullptr;
        EXPECT_TRUE(fl_method_call_respond_error(method_call, "CODE", "MESSAGE",
                                                 details, &error));
        EXPECT_EQ(error, nullptr);
      },
      nullptr, nullptr);
 
  // Trigger the engine to make a method call.
  g_autoptr(FlValue) args = fl_value_new_string("Marco!");
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "test", "Test", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
        EXPECT_STREQ(fl_method_error_response_get_code(
                         FL_METHOD_ERROR_RESPONSE(response)),
                     "CODE");
        EXPECT_STREQ(fl_method_error_response_get_message(
                         FL_METHOD_ERROR_RESPONSE(response)),
                     "MESSAGE");
        FlValue* details = fl_method_error_response_get_details(
            FL_METHOD_ERROR_RESPONSE(response));
        EXPECT_EQ(fl_value_get_type(details), FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(details), "DETAILS");
      },
      &called);
  EXPECT_TRUE(called);
}

References args, channel, error, fl_method_call_get_args(), fl_method_call_get_name(), fl_method_call_respond_error(), fl_method_channel_new(), fl_method_channel_set_method_call_handler(), fl_method_error_response_get_code(), fl_method_error_response_get_details(), fl_method_error_response_get_message(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_new(), fl_standard_method_codec_new(), fl_value_get_string(), fl_value_get_type(), fl_value_new_string(), FL_VALUE_TYPE_STRING, g_autoptr(), method_call, TRUE, and user_data.

◆ TEST() [9/13]

TEST	(	FlMethodChannelTest	,
		ReceiveMethodCallRespondErrorError
	)

Definition at line 492 of file fl_method_channel_test.cc.

                                                              {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
 
  g_autoptr(TestMethodCodec) codec = test_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
  gboolean called = FALSE;
  fl_method_channel_set_method_call_handler(
      channel,
      [](FlMethodChannel* channel, FlMethodCall* method_call,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        g_autoptr(FlValue) details = fl_value_new_int(42);
        g_autoptr(GError) response_error = nullptr;
        EXPECT_FALSE(fl_method_call_respond_error(method_call, "error", "ERROR",
                                                  details, &response_error));
        EXPECT_NE(response_error, nullptr);
        EXPECT_STREQ(response_error->message, "Unsupported type");
      },
      &called, nullptr);
 
  // Trigger the engine to make a method call.
  fl_mock_binary_messenger_invoke_standard_method(messenger, "test", "Test",
                                                  nullptr, nullptr, nullptr);
 
  EXPECT_TRUE(called);
}

References channel, fl_method_call_respond_error(), fl_method_channel_new(), fl_method_channel_set_method_call_handler(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_new(), fl_value_new_int(), g_autoptr(), method_call, test_method_codec_new(), TRUE, and user_data.

◆ TEST() [10/13]

TEST	(	FlMethodChannelTest	,
		ReceiveMethodCallRespondNotImplemented
	)

Definition at line 315 of file fl_method_channel_test.cc.

                                                                  {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
  fl_method_channel_set_method_call_handler(
      channel,
      [](FlMethodChannel* channel, FlMethodCall* method_call,
         gpointer user_data) {
        EXPECT_STREQ(fl_method_call_get_name(method_call), "Test");
        EXPECT_EQ(fl_value_get_type(fl_method_call_get_args(method_call)),
                  FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(fl_method_call_get_args(method_call)),
                     "Marco!");
 
        g_autoptr(GError) error = nullptr;
        EXPECT_TRUE(
            fl_method_call_respond_not_implemented(method_call, &error));
        EXPECT_EQ(error, nullptr);
      },
      nullptr, nullptr);
 
  // Trigger the engine to make a method call.
  g_autoptr(FlValue) args = fl_value_new_string("Marco!");
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "test", "Test", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_NOT_IMPLEMENTED_RESPONSE(response));
      },
      &called);
  EXPECT_TRUE(called);
}

References args, channel, error, fl_method_call_get_args(), fl_method_call_get_name(), fl_method_call_respond_not_implemented(), fl_method_channel_new(), fl_method_channel_set_method_call_handler(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_new(), fl_standard_method_codec_new(), fl_value_get_string(), fl_value_get_type(), fl_value_new_string(), FL_VALUE_TYPE_STRING, g_autoptr(), method_call, TRUE, and user_data.

◆ TEST() [11/13]

TEST	(	FlMethodChannelTest	,
		ReceiveMethodCallRespondSuccess
	)

Definition at line 219 of file fl_method_channel_test.cc.

                                                           {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
  fl_method_channel_set_method_call_handler(
      channel,
      [](FlMethodChannel* channel, FlMethodCall* method_call,
         gpointer user_data) {
        EXPECT_STREQ(fl_method_call_get_name(method_call), "Test");
        EXPECT_EQ(fl_value_get_type(fl_method_call_get_args(method_call)),
                  FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(fl_method_call_get_args(method_call)),
                     "Marco!");
 
        g_autoptr(FlValue) result = fl_value_new_string("Polo!");
        g_autoptr(GError) error = nullptr;
        EXPECT_TRUE(
            fl_method_call_respond_success(method_call, result, &error));
        EXPECT_EQ(error, nullptr);
      },
      nullptr, nullptr);
 
  // Trigger the engine to make a method call.
  g_autoptr(FlValue) args = fl_value_new_string("Marco!");
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "test", "Test", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
        FlValue* result = fl_method_success_response_get_result(
            FL_METHOD_SUCCESS_RESPONSE(response));
        EXPECT_EQ(fl_value_get_type(result), FL_VALUE_TYPE_STRING);
        EXPECT_STREQ(fl_value_get_string(result), "Polo!");
      },
      &called);
  EXPECT_TRUE(called);
}

References args, channel, error, fl_method_call_get_args(), fl_method_call_get_name(), fl_method_call_respond_success(), fl_method_channel_new(), fl_method_channel_set_method_call_handler(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_new(), fl_standard_method_codec_new(), fl_value_get_string(), fl_value_get_type(), fl_value_new_string(), FL_VALUE_TYPE_STRING, g_autoptr(), method_call, TRUE, and user_data.

◆ TEST() [12/13]

TEST	(	FlMethodChannelTest	,
		ReceiveMethodCallRespondSuccessError
	)

Definition at line 454 of file fl_method_channel_test.cc.

                                                                {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
 
  g_autoptr(TestMethodCodec) codec = test_method_codec_new();
  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
  gboolean called = FALSE;
  fl_method_channel_set_method_call_handler(
      channel,
      [](FlMethodChannel* channel, FlMethodCall* method_call,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        g_autoptr(FlValue) result = fl_value_new_int(42);
        g_autoptr(GError) response_error = nullptr;
        EXPECT_FALSE(fl_method_call_respond_success(method_call, result,
                                                    &response_error));
        EXPECT_NE(response_error, nullptr);
        EXPECT_STREQ(response_error->message, "Unsupported type");
 
        // Respond to stop a warning occurring about not responding.
        fl_method_call_respond_not_implemented(method_call, nullptr);
      },
      &called, nullptr);
 
  // Trigger the engine to make a method call.
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "test", "Test", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {},
      nullptr);
 
  EXPECT_TRUE(called);
}

References channel, fl_method_call_respond_not_implemented(), fl_method_call_respond_success(), fl_method_channel_new(), fl_method_channel_set_method_call_handler(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_new(), fl_value_new_int(), g_autoptr(), method_call, test_method_codec_new(), TRUE, and user_data.

◆ TEST() [13/13]

TEST	(	FlMethodChannelTest	,
		ReplaceADisposedMethodChannel
	)

Definition at line 529 of file fl_method_channel_test.cc.

                                                         {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
 
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
 
  // Register the first channel and test if it works.
  FlMethodChannel* channel1 = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
  int first_count = 0;
  fl_method_channel_set_method_call_handler(
      channel1,
      [](FlMethodChannel* channel, FlMethodCall* method_call,
         gpointer user_data) {
        int* first_count = static_cast<int*>(user_data);
        (*first_count)++;
 
        EXPECT_TRUE(
            fl_method_call_respond_success(method_call, nullptr, nullptr));
      },
      &first_count, nullptr);
 
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "test", "Test", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {},
      nullptr);
  EXPECT_EQ(first_count, 1);
 
  // Dispose the first channel.
  g_object_unref(channel1);
 
  // Register the second channel and test if it works.
  g_autoptr(FlMethodChannel) channel2 = fl_method_channel_new(
      FL_BINARY_MESSENGER(messenger), "test", FL_METHOD_CODEC(codec));
  int second_count = 0;
  fl_method_channel_set_method_call_handler(
      channel2,
      [](FlMethodChannel* channel, FlMethodCall* method_call,
         gpointer user_data) {
        int* second_count = static_cast<int*>(user_data);
        (*second_count)++;
 
        EXPECT_TRUE(
            fl_method_call_respond_success(method_call, nullptr, nullptr));
      },
      &second_count, nullptr);
 
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "test", "Test", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {},
      nullptr);
  EXPECT_EQ(first_count, 1);
  EXPECT_EQ(second_count, 1);
}

References channel, fl_method_call_respond_success(), fl_method_channel_new(), fl_method_channel_set_method_call_handler(), fl_mock_binary_messenger_invoke_standard_method(), fl_mock_binary_messenger_new(), fl_standard_method_codec_new(), g_autoptr(), method_call, and user_data.

◆ test_method_codec_class_init()

static void test_method_codec_class_init ( TestMethodCodecClass * klass )

static

Definition at line 430 of file fl_method_channel_test.cc.

                                                                      {
  G_OBJECT_CLASS(klass)->dispose = test_method_codec_dispose;
  FL_METHOD_CODEC_CLASS(klass)->encode_method_call =
      test_method_codec_encode_method_call;
  FL_METHOD_CODEC_CLASS(klass)->decode_method_call =
      test_method_codec_decode_method_call;
  FL_METHOD_CODEC_CLASS(klass)->encode_success_envelope =
      test_method_codec_encode_success_envelope;
  FL_METHOD_CODEC_CLASS(klass)->encode_error_envelope =
      test_method_codec_encode_error_envelope;
  FL_METHOD_CODEC_CLASS(klass)->decode_response =
      test_method_codec_decode_response;
}

References test_method_codec_decode_method_call(), test_method_codec_decode_response(), test_method_codec_dispose(), test_method_codec_encode_error_envelope(), test_method_codec_encode_method_call(), and test_method_codec_encode_success_envelope().

◆ test_method_codec_decode_method_call()

static gboolean test_method_codec_decode_method_call	(	FlMethodCodec *	codec,
		GBytes *	message,
		gchar **	name,
		FlValue **	args,
		GError **	error
	)

static

Definition at line 389 of file fl_method_channel_test.cc.

                                                                     {
  EXPECT_TRUE(TEST_IS_METHOD_CODEC(codec));
  TestMethodCodec* self = TEST_METHOD_CODEC(codec);
  return fl_method_codec_decode_method_call(
      FL_METHOD_CODEC(self->wrapped_codec), message, name, args, error);
}

References args, error, fl_method_codec_decode_method_call(), message, name, and self.

Referenced by test_method_codec_class_init().

◆ test_method_codec_decode_response()

static FlMethodResponse * test_method_codec_decode_response	(	FlMethodCodec *	codec,
		GBytes *	message,
		GError **	error
	)

static

Definition at line 421 of file fl_method_channel_test.cc.

                                                                           {
  EXPECT_TRUE(TEST_IS_METHOD_CODEC(codec));
  TestMethodCodec* self = TEST_METHOD_CODEC(codec);
  return fl_method_codec_decode_response(FL_METHOD_CODEC(self->wrapped_codec),
                                         message, error);
}

References error, fl_method_codec_decode_response(), message, and self.

Referenced by test_method_codec_class_init().

◆ test_method_codec_dispose()

static void test_method_codec_dispose ( GObject * object )

static

Definition at line 369 of file fl_method_channel_test.cc.

                                                       {
  TestMethodCodec* self = TEST_METHOD_CODEC(object);
 
  g_clear_object(&self->wrapped_codec);
 
  G_OBJECT_CLASS(test_method_codec_parent_class)->dispose(object);
}

References self.

Referenced by test_method_codec_class_init().

◆ test_method_codec_encode_error_envelope()

static GBytes * test_method_codec_encode_error_envelope	(	FlMethodCodec *	codec,
		const gchar *	code,
		const gchar *	message,
		FlValue *	details,
		GError **	error
	)

static

Definition at line 410 of file fl_method_channel_test.cc.

                                                                       {
  g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
              "Unsupported type");
  return nullptr;
}

References error, FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_FAILED.

Referenced by test_method_codec_class_init().

◆ test_method_codec_encode_method_call()

static GBytes * test_method_codec_encode_method_call	(	FlMethodCodec *	codec,
		const gchar *	name,
		FlValue *	args,
		GError **	error
	)

static

Definition at line 378 of file fl_method_channel_test.cc.

                                                                    {
  EXPECT_TRUE(TEST_IS_METHOD_CODEC(codec));
  TestMethodCodec* self = TEST_METHOD_CODEC(codec);
  return fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(self->wrapped_codec), name, args, error);
}

References args, error, fl_method_codec_encode_method_call(), name, and self.

Referenced by test_method_codec_class_init().

◆ test_method_codec_encode_success_envelope()

static GBytes * test_method_codec_encode_success_envelope	(	FlMethodCodec *	codec,
		FlValue *	result,
		GError **	error
	)

static

Definition at line 401 of file fl_method_channel_test.cc.

                                                                         {
  g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
              "Unsupported type");
  return nullptr;
}

References error, FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_FAILED.

Referenced by test_method_codec_class_init().

◆ test_method_codec_init()

static void test_method_codec_init ( TestMethodCodec * self )

static

Definition at line 444 of file fl_method_channel_test.cc.

                                                          {
  self->wrapped_codec = fl_standard_method_codec_new();
}

References fl_standard_method_codec_new(), and self.

◆ test_method_codec_new()

TestMethodCodec * test_method_codec_new ( )

Definition at line 448 of file fl_method_channel_test.cc.

                                         {
  return TEST_METHOD_CODEC(g_object_new(test_method_codec_get_type(), nullptr));
}

Referenced by TEST(), and TEST().

Functions

Function Documentation

◆ G_DECLARE_FINAL_TYPE()

◆ TEST() [1/13]

◆ TEST() [2/13]

◆ TEST() [3/13]

◆ TEST() [4/13]

◆ TEST() [5/13]

◆ TEST() [6/13]

◆ TEST() [7/13]

◆ TEST() [8/13]

◆ TEST() [9/13]

◆ TEST() [10/13]

◆ TEST() [11/13]

◆ TEST() [12/13]

◆ TEST() [13/13]

◆ test_method_codec_class_init()

◆ test_method_codec_decode_method_call()

◆ test_method_codec_decode_response()

◆ test_method_codec_dispose()

◆ test_method_codec_encode_error_envelope()

◆ test_method_codec_encode_method_call()

◆ test_method_codec_encode_success_envelope()

◆ test_method_codec_init()

◆ test_method_codec_new()