fl_standard_method_codec_test.cc File Reference

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

Go to the source code of this file.

Functions
	G_DECLARE_FINAL_TYPE (FlTestMethodMessageCodec, fl_test_method_message_codec, FL, TEST_METHOD_MESSAGE_CODEC, FlStandardMessageCodec) struct _FlTestMethodMessageCodec
	G_DEFINE_TYPE (FlTestMethodMessageCodec, fl_test_method_message_codec, fl_standard_message_codec_get_type()) static gboolean write_custom_value(FlStandardMessageCodec *codec
	g_byte_array_append (buffer, &type, sizeof(uint8_t))
	fl_standard_message_codec_write_size (codec, buffer, length)
	g_byte_array_append (buffer, reinterpret_cast< const uint8_t * >(text), length)
static gboolean	fl_test_method_message_codec_write_value (FlStandardMessageCodec *codec, GByteArray *buffer, FlValue *value, GError **error)
static FlValue *	read_custom_value (FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, GError **error)
static FlValue *	fl_test_method_message_codec_read_value_of_type (FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, int type, GError **error)
static void	fl_test_method_message_codec_class_init (FlTestMethodMessageCodecClass *klass)
static void	fl_test_method_message_codec_init (FlTestMethodMessageCodec *self)
static FlTestMethodMessageCodec *	fl_test_method_message_codec_new ()
static gchar *	encode_method_call (const gchar *name, FlValue *args)
static gchar *	encode_success_envelope (FlValue *result)
static gchar *	encode_error_envelope (const gchar *error_code, const gchar *error_message, FlValue *details)
static void	decode_method_call (const char *hex_string, gchar **name, FlValue **args)
static void	decode_error_method_call (const char *hex_string, GQuark domain, gint code)
static void	decode_response_with_success (const char *hex_string, FlValue *result)
static void	decode_response_with_error (const char *hex_string, const gchar *code, const gchar *error_message, FlValue *details)
static void	decode_error_response (const char *hex_string, GQuark domain, gint code)
	TEST (FlStandardMethodCodecTest, EncodeMethodCallNullptrArgs)
	TEST (FlStandardMethodCodecTest, EncodeMethodCallNullArgs)
	TEST (FlStandardMethodCodecTest, EncodeMethodCallStringArgs)
	TEST (FlStandardMethodCodecTest, EncodeMethodCallListArgs)
	TEST (FlStandardMethodCodecTest, DecodeMethodCallNullArgs)
	TEST (FlStandardMethodCodecTest, DecodeMethodCallStringArgs)
	TEST (FlStandardMethodCodecTest, DecodeMethodCallListArgs)
	TEST (FlStandardMethodCodecTest, DecodeMethodCallNoData)
	TEST (FlStandardMethodCodecTest, DecodeMethodCallNullMethodName)
	TEST (FlStandardMethodCodecTest, DecodeMethodCallMissingArgs)
	TEST (FlStandardMethodCodecTest, EncodeSuccessEnvelopeNullptr)
	TEST (FlStandardMethodCodecTest, EncodeSuccessEnvelopeNull)
	TEST (FlStandardMethodCodecTest, EncodeSuccessEnvelopeString)
	TEST (FlStandardMethodCodecTest, EncodeSuccessEnvelopeList)
	TEST (FlStandardMethodCodecTest, EncodeErrorEnvelopeEmptyCode)
	TEST (FlStandardMethodCodecTest, EncodeErrorEnvelopeNonMessageOrDetails)
	TEST (FlStandardMethodCodecTest, EncodeErrorEnvelopeMessage)
	TEST (FlStandardMethodCodecTest, EncodeErrorEnvelopeDetails)
	TEST (FlStandardMethodCodecTest, EncodeErrorEnvelopeMessageAndDetails)
	TEST (FlStandardMethodCodecTest, DecodeResponseSuccessNull)
	TEST (FlStandardMethodCodecTest, DecodeResponseSuccessString)
	TEST (FlStandardMethodCodecTest, DecodeResponseSuccessList)
	TEST (FlStandardMethodCodecTest, DecodeResponseErrorEmptyCode)
	TEST (FlStandardMethodCodecTest, DecodeResponseErrorNoMessageOrDetails)
	TEST (FlStandardMethodCodecTest, DecodeResponseErrorMessage)
	TEST (FlStandardMethodCodecTest, DecodeResponseErrorDetails)
	TEST (FlStandardMethodCodecTest, DecodeResponseErrorMessageAndDetails)
	TEST (FlStandardMethodCodecTest, DecodeResponseSuccessNoData)
	TEST (FlStandardMethodCodecTest, DecodeResponseSuccessExtraData)
	TEST (FlStandardMethodCodecTest, DecodeResponseErrorNoData)
	TEST (FlStandardMethodCodecTest, DecodeResponseErrorMissingMessageAndDetails)
	TEST (FlStandardMethodCodecTest, DecodeResponseErrorMissingDetails)
	TEST (FlStandardMethodCodecTest, DecodeResponseErrorExtraData)
	TEST (FlStandardMethodCodecTest, DecodeResponseNotImplemented)
	TEST (FlStandardMethodCodecTest, DecodeResponseUnknownEnvelope)
	TEST (FlStandardMethodCodecTest, CustomMessageCodec)

Variables
GByteArray *	buffer
GByteArray FlValue *	value
GByteArray FlValue GError **	error
size_t	length = strlen(text)
uint8_t	type = 128
return	TRUE

Function Documentation

decode_error_method_call()

static void decode_error_method_call ( const char *  hex_string, GQuark  domain, gint  code  )

static

Definition at line 170 of file fl_standard_method_codec_test.cc.

                                                {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GBytes) message = hex_string_to_bytes(hex_string);
  g_autoptr(GError) error = nullptr;
  g_autofree gchar* name = nullptr;
  g_autoptr(FlValue) args = nullptr;
  gboolean result = fl_method_codec_decode_method_call(
      FL_METHOD_CODEC(codec), message, &name, &args, &error);
  EXPECT_FALSE(result);
  EXPECT_EQ(name, nullptr);
  EXPECT_EQ(args, nullptr);
  EXPECT_TRUE(g_error_matches(error, domain, code));
}

decode_error_response()

static void decode_error_response ( const char *  hex_string, GQuark  domain, gint  code  )

static

Definition at line 240 of file fl_standard_method_codec_test.cc.

                                             {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GBytes) message = hex_string_to_bytes(hex_string);
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  EXPECT_EQ(response, nullptr);
  EXPECT_TRUE(g_error_matches(error, domain, code));
}

decode_method_call()

static void decode_method_call ( const char *  hex_string, gchar **  name, FlValue **  args  )

static

Definition at line 157 of file fl_standard_method_codec_test.cc.

                                               {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GBytes) message = hex_string_to_bytes(hex_string);
  g_autoptr(GError) error = nullptr;
  gboolean result = fl_method_codec_decode_method_call(
      FL_METHOD_CODEC(codec), message, name, args, &error);
  EXPECT_TRUE(result);
  EXPECT_EQ(error, nullptr);
}

decode_response_with_error()

static void decode_response_with_error ( const char *  hex_string, const gchar *  code, const gchar *  error_message, FlValue *  details  )

static

Definition at line 205 of file fl_standard_method_codec_test.cc.

                                                         {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GBytes) message = hex_string_to_bytes(hex_string);
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  ASSERT_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);
  if (error_message == nullptr) {
    EXPECT_EQ(fl_method_error_response_get_message(
                  FL_METHOD_ERROR_RESPONSE(response)),
              nullptr);
  } else {
    EXPECT_STREQ(fl_method_error_response_get_message(
                     FL_METHOD_ERROR_RESPONSE(response)),
                 error_message);
  }
  if (details == nullptr) {
    EXPECT_EQ(fl_method_error_response_get_details(
                  FL_METHOD_ERROR_RESPONSE(response)),
              nullptr);
  } else {
    EXPECT_TRUE(fl_value_equal(fl_method_error_response_get_details(
                                   FL_METHOD_ERROR_RESPONSE(response)),
                               details));
  }
}

decode_response_with_success()

static void decode_response_with_success ( const char *  hex_string, FlValue *  result  )

static

Definition at line 188 of file fl_standard_method_codec_test.cc.

                                                          {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GBytes) message = hex_string_to_bytes(hex_string);
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), message, &error);
  ASSERT_NE(response, nullptr);
  EXPECT_EQ(error, nullptr);
  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
  EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
                                 FL_METHOD_SUCCESS_RESPONSE(response)),
                             result));
}

encode_error_envelope()

static gchar * encode_error_envelope ( const gchar *  error_code, const gchar *  error_message, FlValue *  details  )

static

Definition at line 143 of file fl_standard_method_codec_test.cc.

                                                      {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_error_envelope(
      FL_METHOD_CODEC(codec), error_code, error_message, details, &error);
  EXPECT_NE(message, nullptr);
  EXPECT_EQ(error, nullptr);
 
  return bytes_to_hex_string(message);
}

encode_method_call()

static gchar * encode_method_call ( const gchar *  name, FlValue *  args  )

static

Definition at line 118 of file fl_standard_method_codec_test.cc.

                                                                   {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), name, args, &error);
  EXPECT_NE(message, nullptr);
  EXPECT_EQ(error, nullptr);
 
  return bytes_to_hex_string(message);
}

encode_success_envelope()

static gchar * encode_success_envelope ( FlValue *  result )

static

Definition at line 131 of file fl_standard_method_codec_test.cc.

                                                       {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) message = fl_method_codec_encode_success_envelope(
      FL_METHOD_CODEC(codec), result, &error);
  EXPECT_NE(message, nullptr);
  EXPECT_EQ(error, nullptr);
 
  return bytes_to_hex_string(message);
}

fl_standard_message_codec_write_size()

fl_standard_message_codec_write_size	(	codec	,
		buffer	,
		length
	)

fl_test_method_message_codec_class_init()

static void fl_test_method_message_codec_class_init ( FlTestMethodMessageCodecClass *  klass )

static

Definition at line 96 of file fl_standard_method_codec_test.cc.

                                          {
  FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->write_value =
      fl_test_method_message_codec_write_value;
  FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->read_value_of_type =
      fl_test_method_message_codec_read_value_of_type;
}

fl_test_method_message_codec_init()

static void fl_test_method_message_codec_init ( FlTestMethodMessageCodec *  self )

static

Definition at line 104 of file fl_standard_method_codec_test.cc.

                                                                              {
  // The following line suppresses a warning for unused function
  FL_IS_TEST_METHOD_MESSAGE_CODEC(self);
}

fl_test_method_message_codec_new()

static FlTestMethodMessageCodec * fl_test_method_message_codec_new ( )

static

Definition at line 109 of file fl_standard_method_codec_test.cc.

                                                                    {
  return FL_TEST_METHOD_MESSAGE_CODEC(
      g_object_new(fl_test_method_message_codec_get_type(), nullptr));
}

fl_test_method_message_codec_read_value_of_type()

static FlValue * fl_test_method_message_codec_read_value_of_type ( FlStandardMessageCodec *  codec, GBytes *  buffer, size_t *  offset, int  type, GError **  error  )

static

Definition at line 81 of file fl_standard_method_codec_test.cc.

                    {
  if (type == 128) {
    return read_custom_value(codec, buffer, offset, error);
  } else {
    return FL_STANDARD_MESSAGE_CODEC_CLASS(
               fl_test_method_message_codec_parent_class)
        ->read_value_of_type(codec, buffer, offset, type, error);
  }
}

fl_test_method_message_codec_write_value()

static gboolean fl_test_method_message_codec_write_value ( FlStandardMessageCodec *  codec, GByteArray *  buffer, FlValue *  value, GError **  error  )

static

Definition at line 41 of file fl_standard_method_codec_test.cc.

                    {
  if (fl_value_get_type(value) == FL_VALUE_TYPE_CUSTOM &&
      fl_value_get_custom_type(value) == 128) {
    return write_custom_value(codec, buffer, value, error);
  } else {
    return FL_STANDARD_MESSAGE_CODEC_CLASS(
               fl_test_method_message_codec_parent_class)
        ->write_value(codec, buffer, value, error);
  }
}

g_byte_array_append() [1/2]

g_byte_array_append	(	buffer	,
		&	type,
		sizeof(uint8_t)
	)

g_byte_array_append() [2/2]

g_byte_array_append	(	buffer	,
		reinterpret_cast< const uint8_t * >	text,
		length
	)

G_DECLARE_FINAL_TYPE()

G_DECLARE_FINAL_TYPE	(	FlTestMethodMessageCodec	,
		fl_test_method_message_codec	,
		FL	,
		TEST_METHOD_MESSAGE_CODEC	,
		FlStandardMessageCodec
	)

Definition at line 12 of file fl_standard_method_codec_test.cc.

                                 {
  FlStandardMessageCodec parent_instance;
};

G_DEFINE_TYPE()

G_DEFINE_TYPE	(	FlTestMethodMessageCodec	,
		fl_test_method_message_codec	,
		fl_standard_message_codec_get_type()
	)

read_custom_value()

static FlValue * read_custom_value ( FlStandardMessageCodec *  codec, GBytes *  buffer, size_t *  offset, GError **  error  )

static

Definition at line 56 of file fl_standard_method_codec_test.cc.

                                                  {
  uint32_t length;
  if (!fl_standard_message_codec_read_size(codec, buffer, offset, &length,
                                           error)) {
    return nullptr;
  }
  if (*offset + length > g_bytes_get_size(buffer)) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR,
                FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA, "Unexpected end of data");
    return nullptr;
  }
  FlValue* value = fl_value_new_custom(
      128,
      g_strndup(static_cast<const gchar*>(g_bytes_get_data(buffer, nullptr)) +
                    *offset,
                length),
      g_free);
  *offset += length;
 
  return value;
}

TEST() [1/36]

TEST	(	FlStandardMethodCodecTest	,
		CustomMessageCodec
	)

Definition at line 482 of file fl_standard_method_codec_test.cc.

                                                    {
  g_autoptr(FlTestMethodMessageCodec) message_codec =
      fl_test_method_message_codec_new();
  g_autoptr(FlStandardMethodCodec) codec =
      fl_standard_method_codec_new_with_message_codec(
          FL_STANDARD_MESSAGE_CODEC(message_codec));
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlValue) value = fl_value_new_custom(128, "hello", nullptr);
  g_autoptr(GBytes) message = fl_method_codec_encode_success_envelope(
      FL_METHOD_CODEC(codec), value, &error);
  EXPECT_NE(message, nullptr);
  EXPECT_EQ(error, nullptr);
  g_autofree gchar* hex_string = bytes_to_hex_string(message);
  EXPECT_STREQ(hex_string, "00800568656c6c6f");
 
  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_SUCCESS_RESPONSE(response));
  FlValue* result = fl_method_success_response_get_result(
      FL_METHOD_SUCCESS_RESPONSE(response));
  ASSERT_EQ(fl_value_get_type(result), FL_VALUE_TYPE_CUSTOM);
  ASSERT_EQ(fl_value_get_custom_type(result), 128);
  EXPECT_STREQ(static_cast<const gchar*>(fl_value_get_custom_value(result)),
               "hello");
}

TEST() [2/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeMethodCallListArgs
	)

Definition at line 294 of file fl_standard_method_codec_test.cc.

                                                          {
  g_autofree gchar* name = nullptr;
  g_autoptr(FlValue) args = nullptr;
  decode_method_call("070568656c6c6f0c020705636f756e74032a000000", &name,
                     &args);
  EXPECT_STREQ(name, "hello");
  ASSERT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_LIST);
  EXPECT_EQ(fl_value_get_length(args), static_cast<size_t>(2));
 
  FlValue* arg0 = fl_value_get_list_value(args, 0);
  ASSERT_EQ(fl_value_get_type(arg0), FL_VALUE_TYPE_STRING);
  EXPECT_STREQ(fl_value_get_string(arg0), "count");
 
  FlValue* arg1 = fl_value_get_list_value(args, 1);
  ASSERT_EQ(fl_value_get_type(arg1), FL_VALUE_TYPE_INT);
  EXPECT_EQ(fl_value_get_int(arg1), 42);
}

TEST() [3/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeMethodCallMissingArgs
	)

Definition at line 322 of file fl_standard_method_codec_test.cc.

                                                             {
  decode_error_method_call("070568656c6c6f", FL_MESSAGE_CODEC_ERROR,
                           FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
}

TEST() [4/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeMethodCallNoData
	)

Definition at line 312 of file fl_standard_method_codec_test.cc.

                                                        {
  decode_error_method_call("", FL_MESSAGE_CODEC_ERROR,
                           FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
}

TEST() [5/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeMethodCallNullArgs
	)

Definition at line 277 of file fl_standard_method_codec_test.cc.

                                                          {
  g_autofree gchar* name = nullptr;
  g_autoptr(FlValue) args = nullptr;
  decode_method_call("070568656c6c6f00", &name, &args);
  EXPECT_STREQ(name, "hello");
  ASSERT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_NULL);
}

TEST() [6/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeMethodCallNullMethodName
	)

Definition at line 317 of file fl_standard_method_codec_test.cc.

                                                                {
  decode_error_method_call("000000", FL_MESSAGE_CODEC_ERROR,
                           FL_MESSAGE_CODEC_ERROR_FAILED);
}

TEST() [7/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeMethodCallStringArgs
	)

Definition at line 285 of file fl_standard_method_codec_test.cc.

                                                            {
  g_autofree gchar* name = nullptr;
  g_autoptr(FlValue) args = nullptr;
  decode_method_call("070568656c6c6f0705776f726c64", &name, &args);
  EXPECT_STREQ(name, "hello");
  ASSERT_EQ(fl_value_get_type(args), FL_VALUE_TYPE_STRING);
  EXPECT_STREQ(fl_value_get_string(args), "world");
}

TEST() [8/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseErrorDetails
	)

Definition at line 419 of file fl_standard_method_codec_test.cc.

                                                            {
  g_autoptr(FlValue) details = fl_value_new_list();
  fl_value_append_take(details, fl_value_new_string("count"));
  fl_value_append_take(details, fl_value_new_int(42));
  decode_response_with_error("0107056572726f72000c020705636f756e74032a000000",
                             "error", nullptr, details);
}

TEST() [9/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseErrorEmptyCode
	)

Definition at line 406 of file fl_standard_method_codec_test.cc.

                                                              {
  decode_response_with_error("0107000000", "", nullptr, nullptr);
}

TEST() [10/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseErrorExtraData
	)

Definition at line 461 of file fl_standard_method_codec_test.cc.

                                                              {
  decode_error_response("0107056572726f72000000", FL_MESSAGE_CODEC_ERROR,
                        FL_MESSAGE_CODEC_ERROR_FAILED);
}

TEST() [11/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseErrorMessage
	)

Definition at line 414 of file fl_standard_method_codec_test.cc.

                                                            {
  decode_response_with_error("0107056572726f7207076d65737361676500", "error",
                             "message", nullptr);
}

TEST() [12/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseErrorMessageAndDetails
	)

Definition at line 427 of file fl_standard_method_codec_test.cc.

                                                                      {
  g_autoptr(FlValue) details = fl_value_new_list();
  fl_value_append_take(details, fl_value_new_string("count"));
  fl_value_append_take(details, fl_value_new_int(42));
  decode_response_with_error(
      "0107056572726f7207076d6573736167650c020705636f756e74032a000000", "error",
      "message", details);
}

TEST() [13/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseErrorMissingDetails
	)

Definition at line 456 of file fl_standard_method_codec_test.cc.

                                                                   {
  decode_error_response("0107056572726f7200", FL_MESSAGE_CODEC_ERROR,
                        FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
}

TEST() [14/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseErrorMissingMessageAndDetails
	)

Definition at line 451 of file fl_standard_method_codec_test.cc.

                                                                             {
  decode_error_response("0107056572726f72", FL_MESSAGE_CODEC_ERROR,
                        FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
}

TEST() [15/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseErrorNoData
	)

Definition at line 446 of file fl_standard_method_codec_test.cc.

                                                           {
  decode_error_response("01", FL_MESSAGE_CODEC_ERROR,
                        FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
}

TEST() [16/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseErrorNoMessageOrDetails
	)

Definition at line 410 of file fl_standard_method_codec_test.cc.

                                                                       {
  decode_response_with_error("0107056572726f720000", "error", nullptr, nullptr);
}

TEST() [17/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseNotImplemented
	)

Definition at line 466 of file fl_standard_method_codec_test.cc.

                                                              {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_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);
  ASSERT_NE(response, nullptr);
  EXPECT_EQ(error, nullptr);
  EXPECT_TRUE(FL_IS_METHOD_NOT_IMPLEMENTED_RESPONSE(response));
}

TEST() [18/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseSuccessExtraData
	)

Definition at line 441 of file fl_standard_method_codec_test.cc.

                                                                {
  decode_error_response("000000", FL_MESSAGE_CODEC_ERROR,
                        FL_MESSAGE_CODEC_ERROR_FAILED);
}

TEST() [19/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseSuccessList
	)

Definition at line 399 of file fl_standard_method_codec_test.cc.

                                                           {
  g_autoptr(FlValue) result = fl_value_new_list();
  fl_value_append_take(result, fl_value_new_string("count"));
  fl_value_append_take(result, fl_value_new_int(42));
  decode_response_with_success("000c020705636f756e74032a000000", result);
}

TEST() [20/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseSuccessNoData
	)

Definition at line 436 of file fl_standard_method_codec_test.cc.

                                                             {
  decode_error_response("00", FL_MESSAGE_CODEC_ERROR,
                        FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
}

TEST() [21/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseSuccessNull
	)

Definition at line 389 of file fl_standard_method_codec_test.cc.

                                                           {
  g_autoptr(FlValue) result = fl_value_new_null();
  decode_response_with_success("0000", result);
}

TEST() [22/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseSuccessString
	)

Definition at line 394 of file fl_standard_method_codec_test.cc.

                                                             {
  g_autoptr(FlValue) result = fl_value_new_string("hello");
  decode_response_with_success("00070568656c6c6f", result);
}

TEST() [23/36]

TEST	(	FlStandardMethodCodecTest	,
		DecodeResponseUnknownEnvelope
	)

Definition at line 477 of file fl_standard_method_codec_test.cc.

                                                               {
  decode_error_response("02", FL_MESSAGE_CODEC_ERROR,
                        FL_MESSAGE_CODEC_ERROR_FAILED);
}

TEST() [24/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeErrorEnvelopeDetails
	)

Definition at line 369 of file fl_standard_method_codec_test.cc.

                                                            {
  g_autoptr(FlValue) details = fl_value_new_list();
  fl_value_append_take(details, fl_value_new_string("count"));
  fl_value_append_take(details, fl_value_new_int(42));
  g_autofree gchar* hex_string =
      encode_error_envelope("error", nullptr, details);
  EXPECT_STREQ(hex_string, "0107056572726f72000c020705636f756e74032a000000");
}

TEST() [25/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeErrorEnvelopeEmptyCode
	)

Definition at line 352 of file fl_standard_method_codec_test.cc.

                                                              {
  g_autofree gchar* hex_string = encode_error_envelope("", nullptr, nullptr);
  EXPECT_STREQ(hex_string, "0107000000");
}

TEST() [26/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeErrorEnvelopeMessage
	)

Definition at line 363 of file fl_standard_method_codec_test.cc.

                                                            {
  g_autofree gchar* hex_string =
      encode_error_envelope("error", "message", nullptr);
  EXPECT_STREQ(hex_string, "0107056572726f7207076d65737361676500");
}

TEST() [27/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeErrorEnvelopeMessageAndDetails
	)

Definition at line 378 of file fl_standard_method_codec_test.cc.

                                                                      {
  g_autoptr(FlValue) details = fl_value_new_list();
  fl_value_append_take(details, fl_value_new_string("count"));
  fl_value_append_take(details, fl_value_new_int(42));
  g_autofree gchar* hex_string =
      encode_error_envelope("error", "message", details);
  EXPECT_STREQ(
      hex_string,
      "0107056572726f7207076d6573736167650c020705636f756e74032a000000");
}

TEST() [28/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeErrorEnvelopeNonMessageOrDetails
	)

Definition at line 357 of file fl_standard_method_codec_test.cc.

                                                                        {
  g_autofree gchar* hex_string =
      encode_error_envelope("error", nullptr, nullptr);
  EXPECT_STREQ(hex_string, "0107056572726f720000");
}

TEST() [29/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeMethodCallListArgs
	)

Definition at line 269 of file fl_standard_method_codec_test.cc.

                                                          {
  g_autoptr(FlValue) args = fl_value_new_list();
  fl_value_append_take(args, fl_value_new_string("count"));
  fl_value_append_take(args, fl_value_new_int(42));
  g_autofree gchar* hex_string = encode_method_call("hello", args);
  EXPECT_STREQ(hex_string, "070568656c6c6f0c020705636f756e74032a000000");
}

TEST() [30/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeMethodCallNullArgs
	)

Definition at line 257 of file fl_standard_method_codec_test.cc.

                                                          {
  g_autoptr(FlValue) value = fl_value_new_null();
  g_autofree gchar* hex_string = encode_method_call("hello", value);
  EXPECT_STREQ(hex_string, "070568656c6c6f00");
}

TEST() [31/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeMethodCallNullptrArgs
	)

Definition at line 252 of file fl_standard_method_codec_test.cc.

                                                             {
  g_autofree gchar* hex_string = encode_method_call("hello", nullptr);
  EXPECT_STREQ(hex_string, "070568656c6c6f00");
}

TEST() [32/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeMethodCallStringArgs
	)

Definition at line 263 of file fl_standard_method_codec_test.cc.

                                                            {
  g_autoptr(FlValue) args = fl_value_new_string("world");
  g_autofree gchar* hex_string = encode_method_call("hello", args);
  EXPECT_STREQ(hex_string, "070568656c6c6f0705776f726c64");
}

TEST() [33/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeSuccessEnvelopeList
	)

Definition at line 344 of file fl_standard_method_codec_test.cc.

                                                           {
  g_autoptr(FlValue) result = fl_value_new_list();
  fl_value_append_take(result, fl_value_new_string("count"));
  fl_value_append_take(result, fl_value_new_int(42));
  g_autofree gchar* hex_string = encode_success_envelope(result);
  EXPECT_STREQ(hex_string, "000c020705636f756e74032a000000");
}

TEST() [34/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeSuccessEnvelopeNull
	)

Definition at line 332 of file fl_standard_method_codec_test.cc.

                                                           {
  g_autoptr(FlValue) result = fl_value_new_null();
  g_autofree gchar* hex_string = encode_success_envelope(result);
  EXPECT_STREQ(hex_string, "0000");
}

TEST() [35/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeSuccessEnvelopeNullptr
	)

Definition at line 327 of file fl_standard_method_codec_test.cc.

                                                              {
  g_autofree gchar* hex_string = encode_success_envelope(nullptr);
  EXPECT_STREQ(hex_string, "0000");
}

TEST() [36/36]

TEST	(	FlStandardMethodCodecTest	,
		EncodeSuccessEnvelopeString
	)

Definition at line 338 of file fl_standard_method_codec_test.cc.

                                                             {
  g_autoptr(FlValue) result = fl_value_new_string("hello");
  g_autofree gchar* hex_string = encode_success_envelope(result);
  EXPECT_STREQ(hex_string, "00070568656c6c6f");
}

Variable Documentation

buffer

GByteArray* buffer

Definition at line 27 of file fl_standard_method_codec_test.cc.

error

GByteArray FlValue GError** error

Initial value:

{
  const gchar* text =
      static_cast<const gchar*>(fl_value_get_custom_value(value))

Definition at line 29 of file fl_standard_method_codec_test.cc.

length

size_t length = strlen(text)

Definition at line 32 of file fl_standard_method_codec_test.cc.

TRUE

return TRUE

Definition at line 38 of file fl_standard_method_codec_test.cc.

type

uint8_t type = 128

Definition at line 34 of file fl_standard_method_codec_test.cc.

value

GByteArray FlValue* value

Definition at line 28 of file fl_standard_method_codec_test.cc.