fl_method_codec_test.cc File Reference

#include "flutter/shell/platform/linux/public/flutter_linux/fl_method_codec.h"
#include <cstring>
#include "flutter/shell/platform/linux/fl_method_codec_private.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_message_codec.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Functions
	G_DECLARE_FINAL_TYPE (FlTestMethodCodec, fl_test_method_codec, FL, TEST_METHOD_CODEC, FlMethodCodec) struct _FlTestMethodCodec
	G_DEFINE_TYPE (FlTestMethodCodec, fl_test_method_codec, fl_method_codec_get_type()) static gchar *message_to_text(GBytes *message)
static GBytes *	text_to_message (const gchar *text)
static GBytes *	fl_test_codec_encode_method_call (FlMethodCodec *codec, const gchar *name, FlValue *args, GError **error)
static gboolean	fl_test_codec_decode_method_call (FlMethodCodec *codec, GBytes *message, gchar **name, FlValue **args, GError **error)
static GBytes *	fl_test_codec_encode_success_envelope (FlMethodCodec *codec, FlValue *result, GError **error)
static GBytes *	fl_test_codec_encode_error_envelope (FlMethodCodec *codec, const gchar *code, const gchar *message, FlValue *details, GError **error)
static FlMethodResponse *	fl_test_codec_decode_response (FlMethodCodec *codec, GBytes *message, GError **error)
static void	fl_test_method_codec_class_init (FlTestMethodCodecClass *klass)
static void	fl_test_method_codec_init (FlTestMethodCodec *self)
static FlTestMethodCodec *	fl_test_method_codec_new ()
	TEST (FlMethodCodecTest, EncodeMethodCall)
	TEST (FlMethodCodecTest, EncodeMethodCallEmptyName)
	TEST (FlMethodCodecTest, EncodeMethodCallArgs)
	TEST (FlMethodCodecTest, EncodeMethodCallError)
	TEST (FlMethodCodecTest, DecodeMethodCall)
	TEST (FlMethodCodecTest, EncodeSuccessEnvelope)
	TEST (FlMethodCodecTest, EncodeSuccessEnvelopeEmpty)
	TEST (FlMethodCodecTest, EncodeSuccessEnvelopeError)
	TEST (FlMethodCodecTest, EncodeErrorEnvelopeNoMessageOrDetails)
	TEST (FlMethodCodecTest, EncodeErrorEnvelopeMessage)
	TEST (FlMethodCodecTest, EncodeErrorEnvelopeDetails)
	TEST (FlMethodCodecTest, EncodeErrorEnvelopeMessageAndDetails)
	TEST (FlMethodCodecTest, DecodeResponseSuccess)
	TEST (FlMethodCodecTest, DecodeResponseNotImplemented)
	TEST (FlMethodCodecTest, DecodeResponseCodecError)
	TEST (FlMethodCodecTest, DecodeResponseError)

Function Documentation

fl_test_codec_decode_method_call()

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

static

Definition at line 65 of file fl_method_codec_test.cc.

                                                                 {
  EXPECT_TRUE(FL_IS_TEST_METHOD_CODEC(codec));
 
  g_autofree gchar* m = message_to_text(message);
 
  if (strcmp(m, "error") == 0) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                "ERROR");
    return FALSE;
  } else {
    *name = g_strdup(m);
    *args = fl_value_new_null();
    return TRUE;
  }
}

fl_test_codec_decode_response()

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

static

Definition at line 142 of file fl_method_codec_test.cc.

                                                                       {
  EXPECT_TRUE(FL_IS_TEST_METHOD_CODEC(codec));
 
  g_autofree gchar* m = message_to_text(message);
  if (strcmp(m, "codec-error") == 0) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                "ERROR");
    return nullptr;
  } else if (strcmp(m, "error") == 0) {
    g_autoptr(FlValue) details = fl_value_new_int(42);
    return FL_METHOD_RESPONSE(
        fl_method_error_response_new("code", "message", details));
  } else {
    g_autoptr(FlValue) result = fl_value_new_string(m);
    return FL_METHOD_RESPONSE(fl_method_success_response_new(result));
  }
}

fl_test_codec_encode_error_envelope()

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

static

Definition at line 106 of file fl_method_codec_test.cc.

                                                                   {
  EXPECT_TRUE(FL_IS_TEST_METHOD_CODEC(codec));
 
  if (details != nullptr && fl_value_get_type(details) != FL_VALUE_TYPE_INT) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                "ERROR");
    return nullptr;
  }
 
  g_autofree gchar* text = nullptr;
  if (message == nullptr) {
    if (details == nullptr ||
        fl_value_get_type(details) == FL_VALUE_TYPE_NULL) {
      text = g_strdup_printf("Error_%s()", code);
    } else {
      text = g_strdup_printf("Error_%s(%" G_GINT64_FORMAT ")", code,
                             fl_value_get_int(details));
    }
  } else {
    if (details == nullptr ||
        fl_value_get_type(details) == FL_VALUE_TYPE_NULL) {
      text = g_strdup_printf("Error_%s(%s)", code, message);
    } else {
      text = g_strdup_printf("Error_%s(%s,%" G_GINT64_FORMAT ")", code, message,
                             fl_value_get_int(details));
    }
  }
 
  return text_to_message(text);
}

fl_test_codec_encode_method_call()

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

static

Definition at line 43 of file fl_method_codec_test.cc.

                                                                {
  EXPECT_TRUE(FL_IS_TEST_METHOD_CODEC(codec));
 
  g_autofree gchar* text = nullptr;
  if (args == nullptr || fl_value_get_type(args) == FL_VALUE_TYPE_NULL) {
    text = g_strdup_printf("%s()", name);
  } else if (fl_value_get_type(args) == FL_VALUE_TYPE_INT) {
    text = g_strdup_printf("%s(%" G_GINT64_FORMAT ")", name,
                           fl_value_get_int(args));
  } else {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                "ERROR");
    return nullptr;
  }
 
  return text_to_message(text);
}

fl_test_codec_encode_success_envelope()

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

static

Definition at line 86 of file fl_method_codec_test.cc.

                                                                     {
  EXPECT_TRUE(FL_IS_TEST_METHOD_CODEC(codec));
 
  g_autofree gchar* text = nullptr;
  if (result == nullptr || fl_value_get_type(result) == FL_VALUE_TYPE_NULL) {
    text = g_strdup("(null)");
  } else if (fl_value_get_type(result) == FL_VALUE_TYPE_INT) {
    text = g_strdup_printf("%" G_GINT64_FORMAT, fl_value_get_int(result));
  } else {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                "ERROR");
    return nullptr;
  }
 
  return text_to_message(text);
}

fl_test_method_codec_class_init()

static void fl_test_method_codec_class_init ( FlTestMethodCodecClass *  klass )

static

Definition at line 162 of file fl_method_codec_test.cc.

                                                                           {
  FL_METHOD_CODEC_CLASS(klass)->encode_method_call =
      fl_test_codec_encode_method_call;
  FL_METHOD_CODEC_CLASS(klass)->decode_method_call =
      fl_test_codec_decode_method_call;
  FL_METHOD_CODEC_CLASS(klass)->encode_success_envelope =
      fl_test_codec_encode_success_envelope;
  FL_METHOD_CODEC_CLASS(klass)->encode_error_envelope =
      fl_test_codec_encode_error_envelope;
  FL_METHOD_CODEC_CLASS(klass)->decode_response = fl_test_codec_decode_response;
}

fl_test_method_codec_init()

static void fl_test_method_codec_init ( FlTestMethodCodec *  self )

static

Definition at line 174 of file fl_method_codec_test.cc.

{}

fl_test_method_codec_new()

static FlTestMethodCodec * fl_test_method_codec_new ( )

static

Definition at line 176 of file fl_method_codec_test.cc.

                                                     {
  return FL_TEST_METHOD_CODEC(
      g_object_new(fl_test_method_codec_get_type(), nullptr));
}

G_DECLARE_FINAL_TYPE()

G_DECLARE_FINAL_TYPE	(	FlTestMethodCodec	,
		fl_test_method_codec	,
		FL	,
		TEST_METHOD_CODEC	,
		FlMethodCodec
	)

Definition at line 13 of file fl_method_codec_test.cc.

                          {
  FlMethodCodec parent_instance;
};

G_DEFINE_TYPE()

G_DEFINE_TYPE	(	FlTestMethodCodec	,
		fl_test_method_codec	,
		fl_method_codec_get_type()
	)

Definition at line 25 of file fl_method_codec_test.cc.

                                               {
  size_t data_length;
  const gchar* data =
      static_cast<const gchar*>(g_bytes_get_data(message, &data_length));
  return g_strndup(data, data_length);
}

TEST() [1/16]

TEST	(	FlMethodCodecTest	,
		DecodeMethodCall
	)

Definition at line 233 of file fl_method_codec_test.cc.

                                          {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GBytes) message = text_to_message("foo");
 
  g_autofree gchar* name = nullptr;
  g_autoptr(FlValue) args = nullptr;
  g_autoptr(GError) error = nullptr;
  gboolean result = fl_method_codec_decode_method_call(
      FL_METHOD_CODEC(codec), message, &name, &args, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_TRUE(result);
 
  EXPECT_STREQ(name, "foo");
  ASSERT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_NULL);
}

TEST() [2/16]

TEST	(	FlMethodCodecTest	,
		DecodeResponseCodecError
	)

Definition at line 374 of file fl_method_codec_test.cc.

                                                  {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GBytes) message = text_to_message("codec-error");
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  EXPECT_TRUE(g_error_matches(error, FL_MESSAGE_CODEC_ERROR,
                              FL_MESSAGE_CODEC_ERROR_FAILED));
  EXPECT_EQ(response, nullptr);
}

TEST() [3/16]

TEST	(	FlMethodCodecTest	,
		DecodeResponseError
	)

Definition at line 387 of file fl_method_codec_test.cc.

                                             {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GBytes) message = text_to_message("error");
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(response, nullptr);
  ASSERT_TRUE(FL_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));
  ASSERT_NE(details, nullptr);
  ASSERT_EQ(fl_value_get_type(details), FL_VALUE_TYPE_INT);
  EXPECT_EQ(fl_value_get_int(details), 42);
}

TEST() [4/16]

TEST	(	FlMethodCodecTest	,
		DecodeResponseNotImplemented
	)

Definition at line 361 of file fl_method_codec_test.cc.

                                                      {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GBytes) message = g_bytes_new(nullptr, 0);
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(response, nullptr);
  ASSERT_TRUE(FL_IS_METHOD_NOT_IMPLEMENTED_RESPONSE(response));
}

TEST() [5/16]

TEST	(	FlMethodCodecTest	,
		DecodeResponseSuccess
	)

Definition at line 343 of file fl_method_codec_test.cc.

                                               {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GBytes) message = text_to_message("echo");
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(response, nullptr);
  ASSERT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
  FlValue* result = fl_method_success_response_get_result(
      FL_METHOD_SUCCESS_RESPONSE(response));
  ASSERT_NE(result, nullptr);
  ASSERT_EQ(fl_value_get_type(result), FL_VALUE_TYPE_STRING);
  EXPECT_STREQ(fl_value_get_string(result), "echo");
}

TEST() [6/16]

TEST	(	FlMethodCodecTest	,
		EncodeErrorEnvelopeDetails
	)

Definition at line 315 of file fl_method_codec_test.cc.

                                                    {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(FlValue) details = fl_value_new_int(42);
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_error_envelope(
      FL_METHOD_CODEC(codec), "code", nullptr, details, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(message, nullptr);
 
  g_autofree gchar* message_text = message_to_text(message);
  EXPECT_STREQ(message_text, "Error_code(42)");
}

TEST() [7/16]

TEST	(	FlMethodCodecTest	,
		EncodeErrorEnvelopeMessage
	)

Definition at line 302 of file fl_method_codec_test.cc.

                                                    {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_error_envelope(
      FL_METHOD_CODEC(codec), "code", "message", nullptr, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(message, nullptr);
 
  g_autofree gchar* message_text = message_to_text(message);
  EXPECT_STREQ(message_text, "Error_code(message)");
}

TEST() [8/16]

TEST	(	FlMethodCodecTest	,
		EncodeErrorEnvelopeMessageAndDetails
	)

Definition at line 329 of file fl_method_codec_test.cc.

                                                              {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(FlValue) details = fl_value_new_int(42);
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_error_envelope(
      FL_METHOD_CODEC(codec), "code", "message", details, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(message, nullptr);
 
  g_autofree gchar* message_text = message_to_text(message);
  EXPECT_STREQ(message_text, "Error_code(message,42)");
}

TEST() [9/16]

TEST	(	FlMethodCodecTest	,
		EncodeErrorEnvelopeNoMessageOrDetails
	)

Definition at line 289 of file fl_method_codec_test.cc.

                                                               {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_error_envelope(
      FL_METHOD_CODEC(codec), "code", nullptr, nullptr, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(message, nullptr);
 
  g_autofree gchar* message_text = message_to_text(message);
  EXPECT_STREQ(message_text, "Error_code()");
}

TEST() [10/16]

TEST	(	FlMethodCodecTest	,
		EncodeMethodCall
	)

Definition at line 181 of file fl_method_codec_test.cc.

                                          {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "foo", nullptr, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(message, nullptr);
 
  g_autofree gchar* message_text = message_to_text(message);
  EXPECT_STREQ(message_text, "foo()");
}

TEST() [11/16]

TEST	(	FlMethodCodecTest	,
		EncodeMethodCallArgs
	)

Definition at line 207 of file fl_method_codec_test.cc.

                                              {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(FlValue) args = fl_value_new_int(42);
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "foo", args, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(message, nullptr);
 
  g_autofree gchar* message_text = message_to_text(message);
  EXPECT_STREQ(message_text, "foo(42)");
}

TEST() [12/16]

TEST	(	FlMethodCodecTest	,
		EncodeMethodCallEmptyName
	)

Definition at line 194 of file fl_method_codec_test.cc.

                                                   {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "", nullptr, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(message, nullptr);
 
  g_autofree gchar* message_text = message_to_text(message);
  EXPECT_STREQ(message_text, "()");
}

TEST() [13/16]

TEST	(	FlMethodCodecTest	,
		EncodeMethodCallError
	)

Definition at line 221 of file fl_method_codec_test.cc.

                                               {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(FlValue) args = fl_value_new_bool(FALSE);
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "foo", args, &error);
  EXPECT_EQ(message, nullptr);
  EXPECT_TRUE(g_error_matches(error, FL_MESSAGE_CODEC_ERROR,
                              FL_MESSAGE_CODEC_ERROR_FAILED));
}

TEST() [14/16]

TEST	(	FlMethodCodecTest	,
		EncodeSuccessEnvelope
	)

Definition at line 250 of file fl_method_codec_test.cc.

                                               {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(FlValue) result = fl_value_new_int(42);
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_success_envelope(
      FL_METHOD_CODEC(codec), result, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(message, nullptr);
 
  g_autofree gchar* message_text = message_to_text(message);
  EXPECT_STREQ(message_text, "42");
}

TEST() [15/16]

TEST	(	FlMethodCodecTest	,
		EncodeSuccessEnvelopeEmpty
	)

Definition at line 264 of file fl_method_codec_test.cc.

                                                    {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_success_envelope(
      FL_METHOD_CODEC(codec), nullptr, &error);
  EXPECT_EQ(error, nullptr);
  EXPECT_NE(message, nullptr);
 
  g_autofree gchar* message_text = message_to_text(message);
  EXPECT_STREQ(message_text, "(null)");
}

TEST() [16/16]

TEST	(	FlMethodCodecTest	,
		EncodeSuccessEnvelopeError
	)

Definition at line 277 of file fl_method_codec_test.cc.

                                                    {
  g_autoptr(FlTestMethodCodec) codec = fl_test_method_codec_new();
 
  g_autoptr(FlValue) result = fl_value_new_string("X");
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_success_envelope(
      FL_METHOD_CODEC(codec), result, &error);
  EXPECT_EQ(message, nullptr);
  EXPECT_TRUE(g_error_matches(error, FL_MESSAGE_CODEC_ERROR,
                              FL_MESSAGE_CODEC_ERROR_FAILED));
}

text_to_message()

static GBytes * text_to_message ( const gchar *  text )

static

Definition at line 38 of file fl_method_codec_test.cc.

                                                  {
  return g_bytes_new(text, strlen(text));
}