Flutter Linux Embedder
Functions | Variables
fl_standard_message_codec_test.cc File Reference
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_message_codec.h"
#include <cmath>
#include "flutter/shell/platform/linux/testing/fl_test.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Functions

static gchar * encode_message_with_codec (FlValue *value, FlMessageCodec *codec)
 
static gchar * encode_message (FlValue *value)
 
static FlValue * decode_message_with_codec (const char *hex_string, FlMessageCodec *codec)
 
static FlValue * decode_message (const char *hex_string)
 
static void decode_error_value (const char *hex_string, GQuark domain, gint code)
 
 TEST (FlStandardMessageCodecTest, EncodeNullptr)
 
 TEST (FlStandardMessageCodecTest, EncodeNull)
 
 TEST (FlStandardMessageCodecTest, DecodeNull)
 
static gchar * encode_bool (gboolean value)
 
 TEST (FlStandardMessageCodecTest, EncodeBoolFalse)
 
 TEST (FlStandardMessageCodecTest, EncodeBoolTrue)
 
static gchar * encode_int (int64_t value)
 
 TEST (FlStandardMessageCodecTest, EncodeIntZero)
 
 TEST (FlStandardMessageCodecTest, EncodeIntOne)
 
 TEST (FlStandardMessageCodecTest, EncodeInt32)
 
 TEST (FlStandardMessageCodecTest, EncodeInt32Min)
 
 TEST (FlStandardMessageCodecTest, EncodeInt32Max)
 
 TEST (FlStandardMessageCodecTest, EncodeInt64)
 
 TEST (FlStandardMessageCodecTest, EncodeInt64Min)
 
 TEST (FlStandardMessageCodecTest, EncodeInt64Max)
 
 TEST (FlStandardMessageCodecTest, DecodeIntZero)
 
 TEST (FlStandardMessageCodecTest, DecodeIntOne)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32Min)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32Max)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64Min)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64Max)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32NoData)
 
 TEST (FlStandardMessageCodecTest, DecodeIntShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeIntShortData2)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64NoData)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64ShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64ShortData2)
 
static gchar * encode_float (double value)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatZero)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatOne)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatMinusOne)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatHalf)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatFraction)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatMinusZero)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatNaN)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatInfinity)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatZero)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatOne)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatMinusOne)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatHalf)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatPi)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatMinusZero)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatNaN)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatInfinity)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatShortData2)
 
static gchar * encode_string (const gchar *value)
 
 TEST (FlStandardMessageCodecTest, EncodeStringEmpty)
 
 TEST (FlStandardMessageCodecTest, EncodeStringHello)
 
 TEST (FlStandardMessageCodecTest, EncodeStringEmptySized)
 
 TEST (FlStandardMessageCodecTest, EncodeStringHelloSized)
 
 TEST (FlStandardMessageCodecTest, DecodeStringEmpty)
 
 TEST (FlStandardMessageCodecTest, DecodeStringHello)
 
 TEST (FlStandardMessageCodecTest, DecodeStringNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeStringLengthNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeStringShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeStringShortData2)
 
 TEST (FlStandardMessageCodecTest, EncodeUint8ListEmpty)
 
 TEST (FlStandardMessageCodecTest, EncodeUint8List)
 
 TEST (FlStandardMessageCodecTest, DecodeUint8ListEmpty)
 
 TEST (FlStandardMessageCodecTest, DecodeUint8List)
 
 TEST (FlStandardMessageCodecTest, DecodeUint8ListNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeUint8ListLengthNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeUint8ListShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeUint8ListShortData2)
 
 TEST (FlStandardMessageCodecTest, EncodeInt32ListEmpty)
 
 TEST (FlStandardMessageCodecTest, EncodeInt32List)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32ListEmpty)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32List)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32ListNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32ListLengthNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32ListShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeInt32ListShortData2)
 
 TEST (FlStandardMessageCodecTest, EncodeInt64ListEmpty)
 
 TEST (FlStandardMessageCodecTest, EncodeInt64List)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64ListEmpty)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64List)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64ListNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64ListLengthNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64ListShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeInt64ListShortData2)
 
 TEST (FlStandardMessageCodecTest, EncodeFloat32ListEmpty)
 
 TEST (FlStandardMessageCodecTest, EncodeFloat32List)
 
 TEST (FlStandardMessageCodecTest, DecodeFloat32ListEmpty)
 
 TEST (FlStandardMessageCodecTest, DecodeFloat32List)
 
 TEST (FlStandardMessageCodecTest, DecodeFloat32ListNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeFloat32ListLengthNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeFloat32ListShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeFloat32ListShortData2)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatListEmpty)
 
 TEST (FlStandardMessageCodecTest, EncodeFloatList)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatListEmpty)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatList)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatListNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatListLengthNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatListShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeFloatListShortData2)
 
 TEST (FlStandardMessageCodecTest, EncodeListEmpty)
 
 TEST (FlStandardMessageCodecTest, EncodeListTypes)
 
 TEST (FlStandardMessageCodecTest, EncodeListNested)
 
 TEST (FlStandardMessageCodecTest, DecodeListEmpty)
 
 TEST (FlStandardMessageCodecTest, DecodeListTypes)
 
 TEST (FlStandardMessageCodecTest, DecodeListNested)
 
 TEST (FlStandardMessageCodecTest, DecodeListNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeListLengthNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeListShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeListShortData2)
 
 TEST (FlStandardMessageCodecTest, EncodeDecodeLargeList)
 
 TEST (FlStandardMessageCodecTest, EncodeMapEmpty)
 
 TEST (FlStandardMessageCodecTest, EncodeMapKeyTypes)
 
 TEST (FlStandardMessageCodecTest, EncodeMapValueTypes)
 
 TEST (FlStandardMessageCodecTest, EncodeMapNested)
 
 TEST (FlStandardMessageCodecTest, DecodeMapEmpty)
 
 TEST (FlStandardMessageCodecTest, DecodeMapKeyTypes)
 
 TEST (FlStandardMessageCodecTest, DecodeMapValueTypes)
 
 TEST (FlStandardMessageCodecTest, DecodeMapNested)
 
 TEST (FlStandardMessageCodecTest, DecodeMapNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeMapLengthNoData)
 
 TEST (FlStandardMessageCodecTest, DecodeMapShortData1)
 
 TEST (FlStandardMessageCodecTest, DecodeMapShortData2)
 
 TEST (FlStandardMessageCodecTest, EncodeDecodeLargeMap)
 
 TEST (FlStandardMessageCodecTest, DecodeUnknownType)
 
 G_DECLARE_FINAL_TYPE (FlTestStandardMessageCodec, fl_test_standard_message_codec, FL, TEST_STANDARD_MESSAGE_CODEC, FlStandardMessageCodec) struct _FlTestStandardMessageCodec
 
 G_DEFINE_TYPE (FlTestStandardMessageCodec, fl_test_standard_message_codec, fl_standard_message_codec_get_type()) static gboolean write_custom_value1(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 write_custom_value2 (FlStandardMessageCodec *codec, GByteArray *buffer, FlValue *value, GError **error)
 
static gboolean fl_test_standard_message_codec_write_value (FlStandardMessageCodec *codec, GByteArray *buffer, FlValue *value, GError **error)
 
static FlValue * read_custom_value1 (FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, GError **error)
 
static FlValue * read_custom_value2 (FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, GError **error)
 
static FlValue * fl_test_standard_message_codec_read_value_of_type (FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, int type, GError **error)
 
static void fl_test_standard_message_codec_class_init (FlTestStandardMessageCodecClass *klass)
 
static void fl_test_standard_message_codec_init (FlTestStandardMessageCodec *self)
 
static FlTestStandardMessageCodec * fl_test_standard_message_codec_new ()
 
 TEST (FlStandardMessageCodecTest, DecodeCustomType)
 
 TEST (FlStandardMessageCodecTest, DecodeCustomTypes)
 
 TEST (FlStandardMessageCodecTest, EncodeCustomType)
 
 TEST (FlStandardMessageCodecTest, EncodeCustomTypes)
 
 TEST (FlStandardMessageCodecTest, EncodeDecode)
 

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_value()

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

Definition at line 55 of file fl_standard_message_codec_test.cc.

57  {
58  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
59  g_autoptr(GBytes) data = hex_string_to_bytes(hex_string);
60  g_autoptr(GError) error = nullptr;
61  g_autoptr(FlValue) value =
62  fl_message_codec_decode_message(FL_MESSAGE_CODEC(codec), data, &error);
63  EXPECT_TRUE(value == nullptr);
64  EXPECT_TRUE(g_error_matches(error, domain, code));
65 }
fl_message_codec_decode_message
G_MODULE_EXPORT FlValue * fl_message_codec_decode_message(FlMessageCodec *self, GBytes *message, GError **error)
Definition: fl_message_codec.cc:33
fl_standard_message_codec_new
G_MODULE_EXPORT FlStandardMessageCodec * fl_standard_message_codec_new()
Definition: fl_standard_message_codec.cc:637
error
GByteArray FlValue GError ** error
Definition: fl_standard_message_codec_test.cc:1112
value
GByteArray FlValue * value
Definition: fl_standard_message_codec_test.cc:1111
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42

References error, fl_message_codec_decode_message(), fl_standard_message_codec_new(), and value.

Referenced by TEST().

◆ decode_message()

static FlValue* decode_message ( const char *  hex_string)
static

Definition at line 48 of file fl_standard_message_codec_test.cc.

48  {
49  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
50  return decode_message_with_codec(hex_string, FL_MESSAGE_CODEC(codec));
51 }
decode_message_with_codec
static FlValue * decode_message_with_codec(const char *hex_string, FlMessageCodec *codec)
Definition: fl_standard_message_codec_test.cc:35

References decode_message_with_codec(), and fl_standard_message_codec_new().

Referenced by TEST().

◆ decode_message_with_codec()

static FlValue* decode_message_with_codec ( const char *  hex_string,
FlMessageCodec *  codec 
)
static

Definition at line 35 of file fl_standard_message_codec_test.cc.

36  {
37  g_autoptr(GBytes) data = hex_string_to_bytes(hex_string);
38  g_autoptr(GError) error = nullptr;
39  g_autoptr(FlValue) value =
40  fl_message_codec_decode_message(codec, data, &error);
41  EXPECT_EQ(error, nullptr);
42  EXPECT_NE(value, nullptr);
43  return fl_value_ref(value);
44 }
fl_value_ref
G_MODULE_EXPORT FlValue * fl_value_ref(FlValue *self)
Definition: fl_value.cc:394

References error, fl_message_codec_decode_message(), fl_value_ref(), and value.

Referenced by decode_message(), and TEST().

◆ encode_bool()

static gchar* encode_bool ( gboolean  value)
static

Definition at line 91 of file fl_standard_message_codec_test.cc.

91  {
92  g_autoptr(FlValue) v = fl_value_new_bool(value);
93  return encode_message(v);
94 }
encode_message
static gchar * encode_message(FlValue *value)
Definition: fl_standard_message_codec_test.cc:28
fl_value_new_bool
G_MODULE_EXPORT FlValue * fl_value_new_bool(bool value)
Definition: fl_value.cc:255

References encode_message(), fl_value_new_bool(), and value.

Referenced by TEST().

◆ encode_float()

static gchar* encode_float ( double  value)
static

Definition at line 229 of file fl_standard_message_codec_test.cc.

229  {
230  g_autoptr(FlValue) v = fl_value_new_float(value);
231  return encode_message(v);
232 }
fl_value_new_float
G_MODULE_EXPORT FlValue * fl_value_new_float(double value)
Definition: fl_value.cc:269

References encode_message(), fl_value_new_float(), and value.

Referenced by TEST().

◆ encode_int()

static gchar* encode_int ( int64_t  value)
static

Definition at line 106 of file fl_standard_message_codec_test.cc.

106  {
107  g_autoptr(FlValue) v = fl_value_new_int(value);
108  return encode_message(v);
109 }
fl_value_new_int
G_MODULE_EXPORT FlValue * fl_value_new_int(int64_t value)
Definition: fl_value.cc:262

References encode_message(), fl_value_new_int(), and value.

Referenced by TEST().

◆ encode_message()

static gchar* encode_message ( FlValue *  value)
static

Definition at line 28 of file fl_standard_message_codec_test.cc.

28  {
29  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
30  return encode_message_with_codec(value, FL_MESSAGE_CODEC(codec));
31 }
encode_message_with_codec
static gchar * encode_message_with_codec(FlValue *value, FlMessageCodec *codec)
Definition: fl_standard_message_codec_test.cc:16

References encode_message_with_codec(), fl_standard_message_codec_new(), and value.

Referenced by encode_bool(), encode_float(), encode_int(), encode_string(), and TEST().

◆ encode_message_with_codec()

static gchar* encode_message_with_codec ( FlValue *  value,
FlMessageCodec *  codec 
)
static

Definition at line 16 of file fl_standard_message_codec_test.cc.

16  {
17  g_autoptr(GError) error = nullptr;
18  g_autoptr(GBytes) message =
19  fl_message_codec_encode_message(codec, value, &error);
20  EXPECT_NE(message, nullptr);
21  EXPECT_EQ(error, nullptr);
22 
23  return bytes_to_hex_string(message);
24 }
fl_message_codec_encode_message
G_MODULE_EXPORT GBytes * fl_message_codec_encode_message(FlMessageCodec *self, FlValue *message, GError **error)
Definition: fl_message_codec.cc:17

References error, fl_message_codec_encode_message(), and value.

Referenced by encode_message(), and TEST().

◆ encode_string()

static gchar* encode_string ( const gchar *  value)
static

Definition at line 337 of file fl_standard_message_codec_test.cc.

337  {
338  g_autoptr(FlValue) v = fl_value_new_string(value);
339  return encode_message(v);
340 }
fl_value_new_string
G_MODULE_EXPORT FlValue * fl_value_new_string(const gchar *value)
Definition: fl_value.cc:276

References encode_message(), fl_value_new_string(), and value.

Referenced by TEST().

◆ fl_standard_message_codec_write_size()

fl_standard_message_codec_write_size ( codec  ,
buffer  ,
length   
)

◆ fl_test_standard_message_codec_class_init()

static void fl_test_standard_message_codec_class_init ( FlTestStandardMessageCodecClass *  klass)
static

Definition at line 1200 of file fl_standard_message_codec_test.cc.

1201  {
1202  FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->write_value =
1203  fl_test_standard_message_codec_write_value;
1204  FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->read_value_of_type =
1205  fl_test_standard_message_codec_read_value_of_type;
1206 }
fl_test_standard_message_codec_write_value
static gboolean fl_test_standard_message_codec_write_value(FlStandardMessageCodec *codec, GByteArray *buffer, FlValue *value, GError **error)
Definition: fl_standard_message_codec_test.cc:1133
fl_test_standard_message_codec_read_value_of_type
static FlValue * fl_test_standard_message_codec_read_value_of_type(FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, int type, GError **error)
Definition: fl_standard_message_codec_test.cc:1183

References fl_test_standard_message_codec_read_value_of_type(), and fl_test_standard_message_codec_write_value().

◆ fl_test_standard_message_codec_init()

static void fl_test_standard_message_codec_init ( FlTestStandardMessageCodec *  self)
static

Definition at line 1208 of file fl_standard_message_codec_test.cc.

1209  {
1210  // The following line suppresses a warning for unused function
1211  FL_IS_TEST_STANDARD_MESSAGE_CODEC(self);
1212 }

◆ fl_test_standard_message_codec_new()

static FlTestStandardMessageCodec* fl_test_standard_message_codec_new ( )
static

Definition at line 1214 of file fl_standard_message_codec_test.cc.

1214  {
1215  return FL_TEST_STANDARD_MESSAGE_CODEC(
1216  g_object_new(fl_test_standard_message_codec_get_type(), nullptr));
1217 }

Referenced by TEST().

◆ fl_test_standard_message_codec_read_value_of_type()

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

Definition at line 1183 of file fl_standard_message_codec_test.cc.

1188  {
1189  if (type == 128) {
1190  return read_custom_value1(codec, buffer, offset, error);
1191  } else if (type == 129) {
1192  return read_custom_value2(codec, buffer, offset, error);
1193  } else {
1194  return FL_STANDARD_MESSAGE_CODEC_CLASS(
1195  fl_test_standard_message_codec_parent_class)
1196  ->read_value_of_type(codec, buffer, offset, type, error);
1197  }
1198 }
type
uint8_t type
Definition: fl_standard_message_codec_test.cc:1117
read_custom_value2
static FlValue * read_custom_value2(FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec_test.cc:1176
read_custom_value1
static FlValue * read_custom_value1(FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec_test.cc:1151
buffer
GByteArray * buffer
Definition: fl_standard_message_codec_test.cc:1110

References buffer, error, read_custom_value1(), read_custom_value2(), and type.

Referenced by fl_test_standard_message_codec_class_init().

◆ fl_test_standard_message_codec_write_value()

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

Definition at line 1133 of file fl_standard_message_codec_test.cc.

1137  {
1138  if (fl_value_get_type(value) == FL_VALUE_TYPE_CUSTOM &&
1139  fl_value_get_custom_type(value) == 128) {
1140  return write_custom_value1(codec, buffer, value, error);
1141  } else if (fl_value_get_type(value) == FL_VALUE_TYPE_CUSTOM &&
1142  fl_value_get_custom_type(value) == 129) {
1143  return write_custom_value2(codec, buffer, value, error);
1144  } else {
1145  return FL_STANDARD_MESSAGE_CODEC_CLASS(
1146  fl_test_standard_message_codec_parent_class)
1147  ->write_value(codec, buffer, value, error);
1148  }
1149 }
write_custom_value2
static gboolean write_custom_value2(FlStandardMessageCodec *codec, GByteArray *buffer, FlValue *value, GError **error)
Definition: fl_standard_message_codec_test.cc:1124
fl_value_get_type
G_MODULE_EXPORT FlValueType fl_value_get_type(FlValue *self)
Definition: fl_value.cc:466
fl_value_get_custom_type
G_MODULE_EXPORT int fl_value_get_custom_type(FlValue *self)
Definition: fl_value.cc:822
FL_VALUE_TYPE_CUSTOM
@ FL_VALUE_TYPE_CUSTOM
Definition: fl_value.h:76

References buffer, error, fl_value_get_custom_type(), fl_value_get_type(), FL_VALUE_TYPE_CUSTOM, value, and write_custom_value2().

Referenced by fl_test_standard_message_codec_class_init().

◆ g_byte_array_append() [1/2]

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

Referenced by fl_standard_message_codec_real_write_value(), fl_standard_method_codec_encode_error_envelope(), fl_standard_method_codec_encode_success_envelope(), write_custom_value2(), write_float64(), write_int32(), write_int64(), write_uint16(), and write_uint32().

◆ 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 ( FlTestStandardMessageCodec  ,
fl_test_standard_message_codec  ,
FL  ,
TEST_STANDARD_MESSAGE_CODEC  ,
FlStandardMessageCodec   
)

Definition at line 1095 of file fl_standard_message_codec_test.cc.

1101  {
1102  FlStandardMessageCodec parent_instance;
1103 };

◆ G_DEFINE_TYPE()

G_DEFINE_TYPE ( FlTestStandardMessageCodec  ,
fl_test_standard_message_codec  ,
fl_standard_message_codec_get_type()   
)

◆ read_custom_value1()

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

Definition at line 1151 of file fl_standard_message_codec_test.cc.

1154  {
1155  uint32_t length;
1156  if (!fl_standard_message_codec_read_size(codec, buffer, offset, &length,
1157  error)) {
1158  return nullptr;
1159  }
1160  if (*offset + length > g_bytes_get_size(buffer)) {
1161  g_set_error(error, FL_MESSAGE_CODEC_ERROR,
1162  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA, "Unexpected end of data");
1163  return nullptr;
1164  }
1165  FlValue* value = fl_value_new_custom(
1166  128,
1167  g_strndup(static_cast<const gchar*>(g_bytes_get_data(buffer, nullptr)) +
1168  *offset,
1169  length),
1170  g_free);
1171  *offset += length;
1172 
1173  return value;
1174 }
FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA
@ FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA
Definition: fl_message_codec.h:34
FL_MESSAGE_CODEC_ERROR
#define FL_MESSAGE_CODEC_ERROR
Definition: fl_message_codec.h:30
fl_standard_message_codec_read_size
G_MODULE_EXPORT gboolean fl_standard_message_codec_read_size(FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, uint32_t *value, GError **error)
Definition: fl_standard_message_codec.cc:657
length
size_t length
Definition: fl_standard_message_codec_test.cc:1115
fl_value_new_custom
G_MODULE_EXPORT FlValue * fl_value_new_custom(int type, gconstpointer value, GDestroyNotify destroy_notify)
Definition: fl_value.cc:374

References buffer, error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA, fl_standard_message_codec_read_size(), fl_value_new_custom(), length, and value.

Referenced by fl_test_standard_message_codec_read_value_of_type().

◆ read_custom_value2()

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

Definition at line 1176 of file fl_standard_message_codec_test.cc.

1179  {
1180  return fl_value_new_custom(129, nullptr, nullptr);
1181 }

References fl_value_new_custom().

Referenced by fl_test_standard_message_codec_read_value_of_type().

◆ TEST() [1/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeCustomType   
)

Definition at line 1219 of file fl_standard_message_codec_test.cc.

1219  {
1220  g_autoptr(FlTestStandardMessageCodec) codec =
1221  fl_test_standard_message_codec_new();
1222  g_autoptr(FlValue) value =
1223  decode_message_with_codec("800568656c6c6f", FL_MESSAGE_CODEC(codec));
1224  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_CUSTOM);
1225  ASSERT_EQ(fl_value_get_custom_type(value), 128);
1226  EXPECT_STREQ(static_cast<const gchar*>(fl_value_get_custom_value(value)),
1227  "hello");
1228 }
fl_test_standard_message_codec_new
static FlTestStandardMessageCodec * fl_test_standard_message_codec_new()
Definition: fl_standard_message_codec_test.cc:1214
fl_value_get_custom_value
G_MODULE_EXPORT gconstpointer fl_value_get_custom_value(FlValue *self)
Definition: fl_value.cc:830

References decode_message_with_codec(), fl_test_standard_message_codec_new(), fl_value_get_custom_type(), fl_value_get_custom_value(), fl_value_get_type(), FL_VALUE_TYPE_CUSTOM, and value.

◆ TEST() [2/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeCustomTypes   
)

Definition at line 1230 of file fl_standard_message_codec_test.cc.

1230  {
1231  g_autoptr(FlTestStandardMessageCodec) codec =
1232  fl_test_standard_message_codec_new();
1233  g_autoptr(FlValue) value = decode_message_with_codec("0c02800568656c6c6f81",
1234  FL_MESSAGE_CODEC(codec));
1235  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_LIST);
1236  EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(2));
1237  FlValue* value1 = fl_value_get_list_value(value, 0);
1238  ASSERT_EQ(fl_value_get_type(value1), FL_VALUE_TYPE_CUSTOM);
1239  ASSERT_EQ(fl_value_get_custom_type(value1), 128);
1240  EXPECT_STREQ(static_cast<const gchar*>(fl_value_get_custom_value(value1)),
1241  "hello");
1242  FlValue* value2 = fl_value_get_list_value(value, 1);
1243  ASSERT_EQ(fl_value_get_type(value2), FL_VALUE_TYPE_CUSTOM);
1244  ASSERT_EQ(fl_value_get_custom_type(value2), 129);
1245 }
fl_value_get_list_value
G_MODULE_EXPORT FlValue * fl_value_get_list_value(FlValue *self, size_t index)
Definition: fl_value.cc:776
fl_value_get_length
G_MODULE_EXPORT size_t fl_value_get_length(FlValue *self)
Definition: fl_value.cc:724
FL_VALUE_TYPE_LIST
@ FL_VALUE_TYPE_LIST
Definition: fl_value.h:73

References decode_message_with_codec(), fl_test_standard_message_codec_new(), fl_value_get_custom_type(), fl_value_get_custom_value(), fl_value_get_length(), fl_value_get_list_value(), fl_value_get_type(), FL_VALUE_TYPE_CUSTOM, FL_VALUE_TYPE_LIST, and value.

◆ TEST() [3/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloat32List   
)

Definition at line 576 of file fl_standard_message_codec_test.cc.

576  {
577  g_autoptr(FlValue) value =
578  decode_message("0e05000000000000000000bf0000803e000000becdcccc3b");
579  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT32_LIST);
580  const float* data = fl_value_get_float32_list(value);
581  EXPECT_FLOAT_EQ(data[0], 0.0f);
582  EXPECT_FLOAT_EQ(data[1], -0.5f);
583  EXPECT_FLOAT_EQ(data[2], 0.25f);
584  EXPECT_FLOAT_EQ(data[3], -0.125f);
585  EXPECT_FLOAT_EQ(data[4], 0.00625f);
586 }
decode_message
static FlValue * decode_message(const char *hex_string)
Definition: fl_standard_message_codec_test.cc:48
fl_value_get_float32_list
G_MODULE_EXPORT const float * fl_value_get_float32_list(FlValue *self)
Definition: fl_value.cc:710
FL_VALUE_TYPE_FLOAT32_LIST
@ FL_VALUE_TYPE_FLOAT32_LIST
Definition: fl_value.h:75

References decode_message(), fl_value_get_float32_list(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT32_LIST, and value.

◆ TEST() [4/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloat32ListEmpty   
)

Definition at line 570 of file fl_standard_message_codec_test.cc.

570  {
571  g_autoptr(FlValue) value = decode_message("0e000000");
572  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT32_LIST);
573  EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(0));
574 }

References decode_message(), fl_value_get_length(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT32_LIST, and value.

◆ TEST() [5/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloat32ListLengthNoData   
)

Definition at line 593 of file fl_standard_message_codec_test.cc.

593  {
594  decode_error_value("0e050000", FL_MESSAGE_CODEC_ERROR,
595  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
596 }
decode_error_value
static void decode_error_value(const char *hex_string, GQuark domain, gint code)
Definition: fl_standard_message_codec_test.cc:55

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [6/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloat32ListNoData   
)

Definition at line 588 of file fl_standard_message_codec_test.cc.

588  {
589  decode_error_value("0e", FL_MESSAGE_CODEC_ERROR,
590  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
591 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [7/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloat32ListShortData1   
)

Definition at line 598 of file fl_standard_message_codec_test.cc.

598  {
599  decode_error_value("0e05000000", FL_MESSAGE_CODEC_ERROR,
600  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
601 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [8/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloat32ListShortData2   
)

Definition at line 603 of file fl_standard_message_codec_test.cc.

603  {
604  decode_error_value("0e05000000000000000000bf0000803e000000becdcccc",
605  FL_MESSAGE_CODEC_ERROR,
606  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
607 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [9/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatHalf   
)

Definition at line 292 of file fl_standard_message_codec_test.cc.

292  {
293  g_autoptr(FlValue) value = decode_message("0600000000000000000000000000e03f");
294  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
295  EXPECT_EQ(fl_value_get_float(value), 0.5);
296 }
fl_value_get_float
G_MODULE_EXPORT double fl_value_get_float(FlValue *self)
Definition: fl_value.cc:675
FL_VALUE_TYPE_FLOAT
@ FL_VALUE_TYPE_FLOAT
Definition: fl_value.h:67

References decode_message(), fl_value_get_float(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT, and value.

◆ TEST() [10/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatInfinity   
)

Definition at line 316 of file fl_standard_message_codec_test.cc.

316  {
317  g_autoptr(FlValue) value = decode_message("0600000000000000000000000000f07f");
318  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
319  EXPECT_TRUE(isinf(fl_value_get_float(value)));
320 }

References decode_message(), fl_value_get_float(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT, and value.

◆ TEST() [11/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatList   
)

Definition at line 631 of file fl_standard_message_codec_test.cc.

631  {
632  g_autoptr(FlValue) value = decode_message(
633  "0b050000000000000000000000000000000000000000e0bf000000000000d03f00000000"
634  "0000c0bf9a9999999999793f");
635  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT_LIST);
636  const double* data = fl_value_get_float_list(value);
637  EXPECT_FLOAT_EQ(data[0], 0.0);
638  EXPECT_FLOAT_EQ(data[1], -0.5);
639  EXPECT_FLOAT_EQ(data[2], 0.25);
640  EXPECT_FLOAT_EQ(data[3], -0.125);
641  EXPECT_FLOAT_EQ(data[4], 0.00625);
642 }
fl_value_get_float_list
G_MODULE_EXPORT const double * fl_value_get_float_list(FlValue *self)
Definition: fl_value.cc:717
FL_VALUE_TYPE_FLOAT_LIST
@ FL_VALUE_TYPE_FLOAT_LIST
Definition: fl_value.h:72

References decode_message(), fl_value_get_float_list(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT_LIST, and value.

◆ TEST() [12/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatListEmpty   
)

Definition at line 625 of file fl_standard_message_codec_test.cc.

625  {
626  g_autoptr(FlValue) value = decode_message("0b00000000000000");
627  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT_LIST);
628  EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(0));
629 }

References decode_message(), fl_value_get_length(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT_LIST, and value.

◆ TEST() [13/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatListLengthNoData   
)

Definition at line 649 of file fl_standard_message_codec_test.cc.

649  {
650  decode_error_value("0b05000000000000", FL_MESSAGE_CODEC_ERROR,
651  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
652 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [14/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatListNoData   
)

Definition at line 644 of file fl_standard_message_codec_test.cc.

644  {
645  decode_error_value("0b", FL_MESSAGE_CODEC_ERROR,
646  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
647 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [15/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatListShortData1   
)

Definition at line 654 of file fl_standard_message_codec_test.cc.

654  {
655  decode_error_value("0b0500000000000000", FL_MESSAGE_CODEC_ERROR,
656  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
657 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [16/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatListShortData2   
)

Definition at line 659 of file fl_standard_message_codec_test.cc.

659  {
660  decode_error_value(
661  "0b050000000000000000000000000000000000000000e0bf000000000000d03f00000000"
662  "0000c0bf9a99"
663  "9999999979",
664  FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
665 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [17/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatMinusOne   
)

Definition at line 286 of file fl_standard_message_codec_test.cc.

286  {
287  g_autoptr(FlValue) value = decode_message("0600000000000000000000000000f0bf");
288  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
289  EXPECT_EQ(fl_value_get_float(value), -1.0);
290 }

References decode_message(), fl_value_get_float(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT, and value.

◆ TEST() [18/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatMinusZero   
)

Definition at line 304 of file fl_standard_message_codec_test.cc.

304  {
305  g_autoptr(FlValue) value = decode_message("06000000000000000000000000000080");
306  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
307  EXPECT_EQ(fl_value_get_float(value), -0.0);
308 }

References decode_message(), fl_value_get_float(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT, and value.

◆ TEST() [19/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatNaN   
)

Definition at line 310 of file fl_standard_message_codec_test.cc.

310  {
311  g_autoptr(FlValue) value = decode_message("0600000000000000000000000000f87f");
312  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
313  EXPECT_TRUE(isnan(fl_value_get_float(value)));
314 }

References decode_message(), fl_value_get_float(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT, and value.

◆ TEST() [20/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatNoData   
)

Definition at line 322 of file fl_standard_message_codec_test.cc.

322  {
323  decode_error_value("060000000000000000", FL_MESSAGE_CODEC_ERROR,
324  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
325 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [21/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatOne   
)

Definition at line 280 of file fl_standard_message_codec_test.cc.

280  {
281  g_autoptr(FlValue) value = decode_message("0600000000000000000000000000f03f");
282  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
283  EXPECT_EQ(fl_value_get_float(value), 1.0);
284 }

References decode_message(), fl_value_get_float(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT, and value.

◆ TEST() [22/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatPi   
)

Definition at line 298 of file fl_standard_message_codec_test.cc.

298  {
299  g_autoptr(FlValue) value = decode_message("0600000000000000182d4454fb210940");
300  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
301  EXPECT_EQ(fl_value_get_float(value), M_PI);
302 }

References decode_message(), fl_value_get_float(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT, and value.

◆ TEST() [23/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatShortData1   
)

Definition at line 327 of file fl_standard_message_codec_test.cc.

327  {
328  decode_error_value("060000000000000000", FL_MESSAGE_CODEC_ERROR,
329  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
330 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [24/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatShortData2   
)

Definition at line 332 of file fl_standard_message_codec_test.cc.

332  {
333  decode_error_value("060000000000000000000000000000", FL_MESSAGE_CODEC_ERROR,
334  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
335 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [25/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeFloatZero   
)

Definition at line 274 of file fl_standard_message_codec_test.cc.

274  {
275  g_autoptr(FlValue) value = decode_message("06000000000000000000000000000000");
276  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
277  EXPECT_EQ(fl_value_get_float(value), 0.0);
278 }

References decode_message(), fl_value_get_float(), fl_value_get_type(), FL_VALUE_TYPE_FLOAT, and value.

◆ TEST() [26/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32   
)

Definition at line 163 of file fl_standard_message_codec_test.cc.

163  {
164  g_autoptr(FlValue) value = decode_message("0367452301");
165  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
166  EXPECT_EQ(fl_value_get_int(value), 0x01234567);
167 }
fl_value_get_int
G_MODULE_EXPORT int64_t fl_value_get_int(FlValue *self)
Definition: fl_value.cc:668
FL_VALUE_TYPE_INT
@ FL_VALUE_TYPE_INT
Definition: fl_value.h:66

References decode_message(), fl_value_get_int(), fl_value_get_type(), FL_VALUE_TYPE_INT, and value.

◆ TEST() [27/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32List   
)

Definition at line 466 of file fl_standard_message_codec_test.cc.

466  {
467  g_autoptr(FlValue) value =
468  decode_message("0905000000000000ffffffff02000000fdffffff04000000");
469  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT32_LIST);
470  const int32_t* data = fl_value_get_int32_list(value);
471  EXPECT_EQ(data[0], 0);
472  EXPECT_EQ(data[1], -1);
473  EXPECT_EQ(data[2], 2);
474  EXPECT_EQ(data[3], -3);
475  EXPECT_EQ(data[4], 4);
476 }
fl_value_get_int32_list
G_MODULE_EXPORT const int32_t * fl_value_get_int32_list(FlValue *self)
Definition: fl_value.cc:696
FL_VALUE_TYPE_INT32_LIST
@ FL_VALUE_TYPE_INT32_LIST
Definition: fl_value.h:70

References decode_message(), fl_value_get_int32_list(), fl_value_get_type(), FL_VALUE_TYPE_INT32_LIST, and value.

◆ TEST() [28/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32ListEmpty   
)

Definition at line 460 of file fl_standard_message_codec_test.cc.

460  {
461  g_autoptr(FlValue) value = decode_message("09000000");
462  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT32_LIST);
463  EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(0));
464 }

References decode_message(), fl_value_get_length(), fl_value_get_type(), FL_VALUE_TYPE_INT32_LIST, and value.

◆ TEST() [29/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32ListLengthNoData   
)

Definition at line 483 of file fl_standard_message_codec_test.cc.

483  {
484  decode_error_value("09050000", FL_MESSAGE_CODEC_ERROR,
485  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
486 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [30/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32ListNoData   
)

Definition at line 478 of file fl_standard_message_codec_test.cc.

478  {
479  decode_error_value("09", FL_MESSAGE_CODEC_ERROR,
480  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
481 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [31/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32ListShortData1   
)

Definition at line 488 of file fl_standard_message_codec_test.cc.

488  {
489  decode_error_value("0905000000", FL_MESSAGE_CODEC_ERROR,
490  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
491 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [32/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32ListShortData2   
)

Definition at line 493 of file fl_standard_message_codec_test.cc.

493  {
494  decode_error_value("090500000000ffffffff02000000fdffffff040000",
495  FL_MESSAGE_CODEC_ERROR,
496  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
497 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [33/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32Max   
)

Definition at line 175 of file fl_standard_message_codec_test.cc.

175  {
176  g_autoptr(FlValue) value = decode_message("03ffffff7f");
177  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
178  EXPECT_EQ(fl_value_get_int(value), G_MAXINT32);
179 }

References decode_message(), fl_value_get_int(), fl_value_get_type(), FL_VALUE_TYPE_INT, and value.

◆ TEST() [34/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32Min   
)

Definition at line 169 of file fl_standard_message_codec_test.cc.

169  {
170  g_autoptr(FlValue) value = decode_message("0300000080");
171  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
172  EXPECT_EQ(fl_value_get_int(value), G_MININT32);
173 }

References decode_message(), fl_value_get_int(), fl_value_get_type(), FL_VALUE_TYPE_INT, and value.

◆ TEST() [35/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt32NoData   
)

Definition at line 199 of file fl_standard_message_codec_test.cc.

199  {
200  decode_error_value("03", FL_MESSAGE_CODEC_ERROR,
201  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
202 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [36/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64   
)

Definition at line 181 of file fl_standard_message_codec_test.cc.

181  {
182  g_autoptr(FlValue) value = decode_message("04efcdab8967452301");
183  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
184  EXPECT_EQ(fl_value_get_int(value), 0x0123456789abcdef);
185 }

References decode_message(), fl_value_get_int(), fl_value_get_type(), FL_VALUE_TYPE_INT, and value.

◆ TEST() [37/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64List   
)

Definition at line 521 of file fl_standard_message_codec_test.cc.

521  {
522  g_autoptr(FlValue) value = decode_message(
523  "0a050000000000000000000000000000ffffffffffffffff0200000000000000fdffffff"
524  "ffffffff0400000000000000");
525  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT64_LIST);
526  const int64_t* data = fl_value_get_int64_list(value);
527  EXPECT_EQ(data[0], 0);
528  EXPECT_EQ(data[1], -1);
529  EXPECT_EQ(data[2], 2);
530  EXPECT_EQ(data[3], -3);
531  EXPECT_EQ(data[4], 4);
532 }
fl_value_get_int64_list
G_MODULE_EXPORT const int64_t * fl_value_get_int64_list(FlValue *self)
Definition: fl_value.cc:703
FL_VALUE_TYPE_INT64_LIST
@ FL_VALUE_TYPE_INT64_LIST
Definition: fl_value.h:71

References decode_message(), fl_value_get_int64_list(), fl_value_get_type(), FL_VALUE_TYPE_INT64_LIST, and value.

◆ TEST() [38/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64ListEmpty   
)

Definition at line 515 of file fl_standard_message_codec_test.cc.

515  {
516  g_autoptr(FlValue) value = decode_message("0a00000000000000");
517  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT64_LIST);
518  EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(0));
519 }

References decode_message(), fl_value_get_length(), fl_value_get_type(), FL_VALUE_TYPE_INT64_LIST, and value.

◆ TEST() [39/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64ListLengthNoData   
)

Definition at line 539 of file fl_standard_message_codec_test.cc.

539  {
540  decode_error_value("0a05000000000000", FL_MESSAGE_CODEC_ERROR,
541  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
542 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [40/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64ListNoData   
)

Definition at line 534 of file fl_standard_message_codec_test.cc.

534  {
535  decode_error_value("0a", FL_MESSAGE_CODEC_ERROR,
536  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
537 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [41/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64ListShortData1   
)

Definition at line 544 of file fl_standard_message_codec_test.cc.

544  {
545  decode_error_value("0a0500000000000000", FL_MESSAGE_CODEC_ERROR,
546  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
547 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [42/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64ListShortData2   
)

Definition at line 549 of file fl_standard_message_codec_test.cc.

549  {
550  decode_error_value(
551  "0a050000000000000000000000000000ffffffffffffffff0200000000000000fdffffff"
552  "ffffffff0400"
553  "0000000000",
554  FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
555 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [43/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64Max   
)

Definition at line 193 of file fl_standard_message_codec_test.cc.

193  {
194  g_autoptr(FlValue) value = decode_message("04ffffffffffffff7f");
195  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
196  EXPECT_EQ(fl_value_get_int(value), G_MAXINT64);
197 }

References decode_message(), fl_value_get_int(), fl_value_get_type(), FL_VALUE_TYPE_INT, and value.

◆ TEST() [44/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64Min   
)

Definition at line 187 of file fl_standard_message_codec_test.cc.

187  {
188  g_autoptr(FlValue) value = decode_message("040000000000000080");
189  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
190  EXPECT_EQ(fl_value_get_int(value), G_MININT64);
191 }

References decode_message(), fl_value_get_int(), fl_value_get_type(), FL_VALUE_TYPE_INT, and value.

◆ TEST() [45/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64NoData   
)

Definition at line 214 of file fl_standard_message_codec_test.cc.

214  {
215  decode_error_value("04", FL_MESSAGE_CODEC_ERROR,
216  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
217 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [46/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64ShortData1   
)

Definition at line 219 of file fl_standard_message_codec_test.cc.

219  {
220  decode_error_value("04ef", FL_MESSAGE_CODEC_ERROR,
221  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
222 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [47/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeInt64ShortData2   
)

Definition at line 224 of file fl_standard_message_codec_test.cc.

224  {
225  decode_error_value("04efcdab89674523", FL_MESSAGE_CODEC_ERROR,
226  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
227 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [48/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeIntOne   
)

Definition at line 157 of file fl_standard_message_codec_test.cc.

157  {
158  g_autoptr(FlValue) value = decode_message("0301000000");
159  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
160  EXPECT_EQ(fl_value_get_int(value), 1);
161 }

References decode_message(), fl_value_get_int(), fl_value_get_type(), FL_VALUE_TYPE_INT, and value.

◆ TEST() [49/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeIntShortData1   
)

Definition at line 204 of file fl_standard_message_codec_test.cc.

204  {
205  decode_error_value("0367", FL_MESSAGE_CODEC_ERROR,
206  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
207 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [50/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeIntShortData2   
)

Definition at line 209 of file fl_standard_message_codec_test.cc.

209  {
210  decode_error_value("03674523", FL_MESSAGE_CODEC_ERROR,
211  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
212 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [51/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeIntZero   
)

Definition at line 151 of file fl_standard_message_codec_test.cc.

151  {
152  g_autoptr(FlValue) value = decode_message("0300000000");
153  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
154  EXPECT_EQ(fl_value_get_int(value), 0);
155 }

References decode_message(), fl_value_get_int(), fl_value_get_type(), FL_VALUE_TYPE_INT, and value.

◆ TEST() [52/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeListEmpty   
)

Definition at line 707 of file fl_standard_message_codec_test.cc.

707  {
708  g_autoptr(FlValue) value = decode_message("0c00");
709  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_LIST);
710  EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(0));
711 }

References decode_message(), fl_value_get_length(), fl_value_get_type(), FL_VALUE_TYPE_LIST, and value.

◆ TEST() [53/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeListLengthNoData   
)

Definition at line 770 of file fl_standard_message_codec_test.cc.

770  {
771  decode_error_value("0c07", FL_MESSAGE_CODEC_ERROR,
772  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
773 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [54/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeListNested   
)

Definition at line 742 of file fl_standard_message_codec_test.cc.

742  {
743  g_autoptr(FlValue) value = decode_message(
744  "0c020c05030000000003020000000304000000030600000003080000000c"
745  "0503010000000303000000030500000003070000000309000000");
746  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_LIST);
747  ASSERT_EQ(fl_value_get_length(value), static_cast<size_t>(2));
748  FlValue* even_list = fl_value_get_list_value(value, 0);
749  ASSERT_EQ(fl_value_get_type(even_list), FL_VALUE_TYPE_LIST);
750  ASSERT_EQ(fl_value_get_length(even_list), static_cast<size_t>(5));
751  FlValue* odd_list = fl_value_get_list_value(value, 1);
752  ASSERT_EQ(fl_value_get_type(odd_list), FL_VALUE_TYPE_LIST);
753  ASSERT_EQ(fl_value_get_length(odd_list), static_cast<size_t>(5));
754  for (int i = 0; i < 5; i++) {
755  FlValue* v = fl_value_get_list_value(even_list, i);
756  ASSERT_EQ(fl_value_get_type(v), FL_VALUE_TYPE_INT);
757  EXPECT_EQ(fl_value_get_int(v), i * 2);
758 
759  v = fl_value_get_list_value(odd_list, i);
760  ASSERT_EQ(fl_value_get_type(v), FL_VALUE_TYPE_INT);
761  EXPECT_EQ(fl_value_get_int(v), i * 2 + 1);
762  }
763 }
i
int i
Definition: fl_socket_accessible.cc:18

References decode_message(), fl_value_get_int(), fl_value_get_length(), fl_value_get_list_value(), fl_value_get_type(), FL_VALUE_TYPE_INT, FL_VALUE_TYPE_LIST, i, and value.

◆ TEST() [55/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeListNoData   
)

Definition at line 765 of file fl_standard_message_codec_test.cc.

765  {
766  decode_error_value("0c", FL_MESSAGE_CODEC_ERROR,
767  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
768 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [56/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeListShortData1   
)

Definition at line 775 of file fl_standard_message_codec_test.cc.

775  {
776  decode_error_value("0c0700", FL_MESSAGE_CODEC_ERROR,
777  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
778 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [57/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeListShortData2   
)

Definition at line 780 of file fl_standard_message_codec_test.cc.

780  {
781  decode_error_value(
782  "0c070001032a00000006000000000000182d4454fb210940070568656c6c6f0c000d",
783  FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
784 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [58/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeListTypes   
)

Definition at line 713 of file fl_standard_message_codec_test.cc.

713  {
714  g_autoptr(FlValue) value = decode_message(
715  "0c070001032a00000006000000000000182d4454fb210940070568656c6c6f0c000d00");
716  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_LIST);
717  ASSERT_EQ(fl_value_get_length(value), static_cast<size_t>(7));
718  ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 0)),
719  FL_VALUE_TYPE_NULL);
720  ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 1)),
721  FL_VALUE_TYPE_BOOL);
722  EXPECT_TRUE(fl_value_get_bool(fl_value_get_list_value(value, 1)));
723  ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 2)),
724  FL_VALUE_TYPE_INT);
725  EXPECT_EQ(fl_value_get_int(fl_value_get_list_value(value, 2)), 42);
726  ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 3)),
727  FL_VALUE_TYPE_FLOAT);
728  EXPECT_FLOAT_EQ(fl_value_get_float(fl_value_get_list_value(value, 3)), M_PI);
729  ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 4)),
730  FL_VALUE_TYPE_STRING);
731  EXPECT_STREQ(fl_value_get_string(fl_value_get_list_value(value, 4)), "hello");
732  ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 5)),
733  FL_VALUE_TYPE_LIST);
734  ASSERT_EQ(fl_value_get_length(fl_value_get_list_value(value, 5)),
735  static_cast<size_t>(0));
736  ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 6)),
737  FL_VALUE_TYPE_MAP);
738  ASSERT_EQ(fl_value_get_length(fl_value_get_list_value(value, 6)),
739  static_cast<size_t>(0));
740 }
fl_value_get_bool
G_MODULE_EXPORT bool fl_value_get_bool(FlValue *self)
Definition: fl_value.cc:661
fl_value_get_string
G_MODULE_EXPORT const gchar * fl_value_get_string(FlValue *self)
Definition: fl_value.cc:682
FL_VALUE_TYPE_STRING
@ FL_VALUE_TYPE_STRING
Definition: fl_value.h:68
FL_VALUE_TYPE_NULL
@ FL_VALUE_TYPE_NULL
Definition: fl_value.h:64
FL_VALUE_TYPE_BOOL
@ FL_VALUE_TYPE_BOOL
Definition: fl_value.h:65
FL_VALUE_TYPE_MAP
@ FL_VALUE_TYPE_MAP
Definition: fl_value.h:74

References decode_message(), fl_value_get_bool(), fl_value_get_float(), fl_value_get_int(), fl_value_get_length(), fl_value_get_list_value(), fl_value_get_string(), fl_value_get_type(), FL_VALUE_TYPE_BOOL, FL_VALUE_TYPE_FLOAT, FL_VALUE_TYPE_INT, FL_VALUE_TYPE_LIST, FL_VALUE_TYPE_MAP, FL_VALUE_TYPE_NULL, FL_VALUE_TYPE_STRING, and value.

◆ TEST() [59/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeMapEmpty   
)

Definition at line 873 of file fl_standard_message_codec_test.cc.

873  {
874  g_autoptr(FlValue) value = decode_message("0d00");
875  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
876  ASSERT_EQ(fl_value_get_length(value), static_cast<size_t>(0));
877 }

References decode_message(), fl_value_get_length(), fl_value_get_type(), FL_VALUE_TYPE_MAP, and value.

◆ TEST() [60/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeMapKeyTypes   
)

Definition at line 879 of file fl_standard_message_codec_test.cc.

879  {
880  g_autoptr(FlValue) value = decode_message(
881  "0d070007046e756c6c010704626f6f6c032a0000000703696e74060000000000182d4454"
882  "fb2109400705666c6f6174070568656c6c6f0706737472696e670c0007046c6973740d00"
883  "07036d6170");
884  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
885  ASSERT_EQ(fl_value_get_length(value), static_cast<size_t>(7));
886 
887  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 0)),
888  FL_VALUE_TYPE_NULL);
889  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 0)),
890  FL_VALUE_TYPE_STRING);
891  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_value(value, 0)), "null");
892 
893  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 1)),
894  FL_VALUE_TYPE_BOOL);
895  EXPECT_TRUE(fl_value_get_bool(fl_value_get_map_key(value, 1)));
896  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 1)),
897  FL_VALUE_TYPE_STRING);
898  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_value(value, 1)), "bool");
899 
900  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 2)),
901  FL_VALUE_TYPE_INT);
902  EXPECT_EQ(fl_value_get_int(fl_value_get_map_key(value, 2)), 42);
903  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 2)),
904  FL_VALUE_TYPE_STRING);
905  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_value(value, 2)), "int");
906 
907  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 3)),
908  FL_VALUE_TYPE_FLOAT);
909  EXPECT_FLOAT_EQ(fl_value_get_float(fl_value_get_map_key(value, 3)), M_PI);
910  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 3)),
911  FL_VALUE_TYPE_STRING);
912  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_value(value, 3)), "float");
913 
914  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 4)),
915  FL_VALUE_TYPE_STRING);
916  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 4)), "hello");
917  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 4)),
918  FL_VALUE_TYPE_STRING);
919  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_value(value, 4)), "string");
920 
921  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 5)),
922  FL_VALUE_TYPE_LIST);
923  ASSERT_EQ(fl_value_get_length(fl_value_get_map_key(value, 5)),
924  static_cast<size_t>(0));
925  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 5)),
926  FL_VALUE_TYPE_STRING);
927  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_value(value, 5)), "list");
928 
929  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 6)),
930  FL_VALUE_TYPE_MAP);
931  ASSERT_EQ(fl_value_get_length(fl_value_get_map_key(value, 6)),
932  static_cast<size_t>(0));
933  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 6)),
934  FL_VALUE_TYPE_STRING);
935  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_value(value, 6)), "map");
936 }
fl_value_get_map_value
G_MODULE_EXPORT FlValue * fl_value_get_map_value(FlValue *self, size_t index)
Definition: fl_value.cc:792
fl_value_get_map_key
G_MODULE_EXPORT FlValue * fl_value_get_map_key(FlValue *self, size_t index)
Definition: fl_value.cc:784

References decode_message(), fl_value_get_bool(), fl_value_get_float(), fl_value_get_int(), fl_value_get_length(), fl_value_get_map_key(), fl_value_get_map_value(), fl_value_get_string(), fl_value_get_type(), FL_VALUE_TYPE_BOOL, FL_VALUE_TYPE_FLOAT, FL_VALUE_TYPE_INT, FL_VALUE_TYPE_LIST, FL_VALUE_TYPE_MAP, FL_VALUE_TYPE_NULL, FL_VALUE_TYPE_STRING, and value.

◆ TEST() [61/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeMapLengthNoData   
)

Definition at line 1049 of file fl_standard_message_codec_test.cc.

1049  {
1050  decode_error_value("0d07", FL_MESSAGE_CODEC_ERROR,
1051  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
1052 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [62/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeMapNested   
)

Definition at line 997 of file fl_standard_message_codec_test.cc.

997  {
998  g_autoptr(FlValue) value = decode_message(
999  "0d02070a7374722d746f2d696e740d0407047a65726f030000000007036f6e6503010000"
1000  "00070374776f0302000000070574687265650303000000070a696e742d746f2d7374720d"
1001  "04030000000007047a65726f030100000007036f6e650302000000070374776f03030000"
1002  "0007057468726565");
1003  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
1004  ASSERT_EQ(fl_value_get_length(value), static_cast<size_t>(2));
1005 
1006  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 0)),
1007  FL_VALUE_TYPE_STRING);
1008  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 0)),
1009  "str-to-int");
1010  FlValue* str_to_int = fl_value_get_map_value(value, 0);
1011  ASSERT_EQ(fl_value_get_type(str_to_int), FL_VALUE_TYPE_MAP);
1012  ASSERT_EQ(fl_value_get_length(str_to_int), static_cast<size_t>(4));
1013 
1014  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 1)),
1015  FL_VALUE_TYPE_STRING);
1016  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 1)),
1017  "int-to-str");
1018  FlValue* int_to_str = fl_value_get_map_value(value, 1);
1019  ASSERT_EQ(fl_value_get_type(int_to_str), FL_VALUE_TYPE_MAP);
1020  ASSERT_EQ(fl_value_get_length(int_to_str), static_cast<size_t>(4));
1021 
1022  const char* numbers[] = {"zero", "one", "two", "three", nullptr};
1023  for (int i = 0; numbers[i] != nullptr; i++) {
1024  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(str_to_int, i)),
1025  FL_VALUE_TYPE_STRING);
1026  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(str_to_int, i)),
1027  numbers[i]);
1028 
1029  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(str_to_int, i)),
1030  FL_VALUE_TYPE_INT);
1031  EXPECT_EQ(fl_value_get_int(fl_value_get_map_value(str_to_int, i)), i);
1032 
1033  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(int_to_str, i)),
1034  FL_VALUE_TYPE_INT);
1035  EXPECT_EQ(fl_value_get_int(fl_value_get_map_key(int_to_str, i)), i);
1036 
1037  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(int_to_str, i)),
1038  FL_VALUE_TYPE_STRING);
1039  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_value(int_to_str, i)),
1040  numbers[i]);
1041  }
1042 }

References decode_message(), fl_value_get_int(), fl_value_get_length(), fl_value_get_map_key(), fl_value_get_map_value(), fl_value_get_string(), fl_value_get_type(), FL_VALUE_TYPE_INT, FL_VALUE_TYPE_MAP, FL_VALUE_TYPE_STRING, i, and value.

◆ TEST() [63/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeMapNoData   
)

Definition at line 1044 of file fl_standard_message_codec_test.cc.

1044  {
1045  decode_error_value("0d", FL_MESSAGE_CODEC_ERROR,
1046  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
1047 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [64/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeMapShortData1   
)

Definition at line 1054 of file fl_standard_message_codec_test.cc.

1054  {
1055  decode_error_value("0d0707", FL_MESSAGE_CODEC_ERROR,
1056  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
1057 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [65/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeMapShortData2   
)

Definition at line 1059 of file fl_standard_message_codec_test.cc.

1059  {
1060  decode_error_value(
1061  "0d0707046e756c6c000704626f6f6c010703696e74032a0000000705666c6f6174060000"
1062  "00000000182d4454fb2109400706737472696e67070568656c6c6f07046c6973740c0007"
1063  "036d61700d",
1064  FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
1065 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [66/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeMapValueTypes   
)

Definition at line 938 of file fl_standard_message_codec_test.cc.

938  {
939  g_autoptr(FlValue) value = decode_message(
940  "0d0707046e756c6c000704626f6f6c010703696e74032a0000000705666c6f6174060000"
941  "00000000182d4454fb2109400706737472696e67070568656c6c6f07046c6973740c0007"
942  "036d61700d00");
943  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
944  ASSERT_EQ(fl_value_get_length(value), static_cast<size_t>(7));
945 
946  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 0)),
947  FL_VALUE_TYPE_STRING);
948  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 0)), "null");
949  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 0)),
950  FL_VALUE_TYPE_NULL);
951 
952  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 1)),
953  FL_VALUE_TYPE_STRING);
954  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 1)), "bool");
955  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 1)),
956  FL_VALUE_TYPE_BOOL);
957  EXPECT_TRUE(fl_value_get_bool(fl_value_get_map_value(value, 1)));
958 
959  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 2)),
960  FL_VALUE_TYPE_STRING);
961  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 2)), "int");
962  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 2)),
963  FL_VALUE_TYPE_INT);
964  EXPECT_EQ(fl_value_get_int(fl_value_get_map_value(value, 2)), 42);
965 
966  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 3)),
967  FL_VALUE_TYPE_STRING);
968  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 3)), "float");
969  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 3)),
970  FL_VALUE_TYPE_FLOAT);
971  EXPECT_FLOAT_EQ(fl_value_get_float(fl_value_get_map_value(value, 3)), M_PI);
972 
973  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 4)),
974  FL_VALUE_TYPE_STRING);
975  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 4)), "string");
976  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 4)),
977  FL_VALUE_TYPE_STRING);
978  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_value(value, 4)), "hello");
979 
980  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 5)),
981  FL_VALUE_TYPE_STRING);
982  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 5)), "list");
983  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 5)),
984  FL_VALUE_TYPE_LIST);
985  ASSERT_EQ(fl_value_get_length(fl_value_get_map_value(value, 5)),
986  static_cast<size_t>(0));
987 
988  ASSERT_EQ(fl_value_get_type(fl_value_get_map_key(value, 6)),
989  FL_VALUE_TYPE_STRING);
990  EXPECT_STREQ(fl_value_get_string(fl_value_get_map_key(value, 6)), "map");
991  ASSERT_EQ(fl_value_get_type(fl_value_get_map_value(value, 6)),
992  FL_VALUE_TYPE_MAP);
993  ASSERT_EQ(fl_value_get_length(fl_value_get_map_value(value, 6)),
994  static_cast<size_t>(0));
995 }

References decode_message(), fl_value_get_bool(), fl_value_get_float(), fl_value_get_int(), fl_value_get_length(), fl_value_get_map_key(), fl_value_get_map_value(), fl_value_get_string(), fl_value_get_type(), FL_VALUE_TYPE_BOOL, FL_VALUE_TYPE_FLOAT, FL_VALUE_TYPE_INT, FL_VALUE_TYPE_LIST, FL_VALUE_TYPE_MAP, FL_VALUE_TYPE_NULL, FL_VALUE_TYPE_STRING, and value.

◆ TEST() [67/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeNull   
)

Definition at line 78 of file fl_standard_message_codec_test.cc.

78  {
79  // Regression test for https://github.com/flutter/flutter/issues/128704.
80 
81  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
82  g_autoptr(GBytes) data = g_bytes_new(nullptr, 0);
83  g_autoptr(GError) error = nullptr;
84  g_autoptr(FlValue) value =
85  fl_message_codec_decode_message(FL_MESSAGE_CODEC(codec), data, &error);
86 
87  EXPECT_FALSE(value == nullptr);
88  EXPECT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_NULL);
89 }

References error, fl_message_codec_decode_message(), fl_standard_message_codec_new(), fl_value_get_type(), FL_VALUE_TYPE_NULL, and value.

◆ TEST() [68/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeStringEmpty   
)

Definition at line 364 of file fl_standard_message_codec_test.cc.

364  {
365  g_autoptr(FlValue) value = decode_message("0700");
366  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
367  EXPECT_STREQ(fl_value_get_string(value), "");
368 }

References decode_message(), fl_value_get_string(), fl_value_get_type(), FL_VALUE_TYPE_STRING, and value.

◆ TEST() [69/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeStringHello   
)

Definition at line 370 of file fl_standard_message_codec_test.cc.

370  {
371  g_autoptr(FlValue) value = decode_message("070568656c6c6f");
372  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
373  EXPECT_STREQ(fl_value_get_string(value), "hello");
374 }

References decode_message(), fl_value_get_string(), fl_value_get_type(), FL_VALUE_TYPE_STRING, and value.

◆ TEST() [70/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeStringLengthNoData   
)

Definition at line 381 of file fl_standard_message_codec_test.cc.

381  {
382  decode_error_value("0705", FL_MESSAGE_CODEC_ERROR,
383  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
384 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [71/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeStringNoData   
)

Definition at line 376 of file fl_standard_message_codec_test.cc.

376  {
377  decode_error_value("07", FL_MESSAGE_CODEC_ERROR,
378  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
379 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [72/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeStringShortData1   
)

Definition at line 386 of file fl_standard_message_codec_test.cc.

386  {
387  decode_error_value("070568", FL_MESSAGE_CODEC_ERROR,
388  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
389 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [73/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeStringShortData2   
)

Definition at line 391 of file fl_standard_message_codec_test.cc.

391  {
392  decode_error_value("070568656c6c", FL_MESSAGE_CODEC_ERROR,
393  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
394 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [74/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeUint8List   
)

Definition at line 415 of file fl_standard_message_codec_test.cc.

415  {
416  g_autoptr(FlValue) value = decode_message("08050001020304");
417  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_UINT8_LIST);
418  EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(5));
419  const uint8_t* data = fl_value_get_uint8_list(value);
420  EXPECT_EQ(data[0], 0);
421  EXPECT_EQ(data[1], 1);
422  EXPECT_EQ(data[2], 2);
423  EXPECT_EQ(data[3], 3);
424  EXPECT_EQ(data[4], 4);
425 }
fl_value_get_uint8_list
G_MODULE_EXPORT const uint8_t * fl_value_get_uint8_list(FlValue *self)
Definition: fl_value.cc:689
FL_VALUE_TYPE_UINT8_LIST
@ FL_VALUE_TYPE_UINT8_LIST
Definition: fl_value.h:69

References decode_message(), fl_value_get_length(), fl_value_get_type(), fl_value_get_uint8_list(), FL_VALUE_TYPE_UINT8_LIST, and value.

◆ TEST() [75/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeUint8ListEmpty   
)

Definition at line 409 of file fl_standard_message_codec_test.cc.

409  {
410  g_autoptr(FlValue) value = decode_message("0800");
411  ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_UINT8_LIST);
412  EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(0));
413 }

References decode_message(), fl_value_get_length(), fl_value_get_type(), FL_VALUE_TYPE_UINT8_LIST, and value.

◆ TEST() [76/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeUint8ListLengthNoData   
)

Definition at line 432 of file fl_standard_message_codec_test.cc.

432  {
433  decode_error_value("0805", FL_MESSAGE_CODEC_ERROR,
434  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
435 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [77/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeUint8ListNoData   
)

Definition at line 427 of file fl_standard_message_codec_test.cc.

427  {
428  decode_error_value("08", FL_MESSAGE_CODEC_ERROR,
429  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
430 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [78/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeUint8ListShortData1   
)

Definition at line 437 of file fl_standard_message_codec_test.cc.

437  {
438  decode_error_value("080500", FL_MESSAGE_CODEC_ERROR,
439  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
440 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [79/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeUint8ListShortData2   
)

Definition at line 442 of file fl_standard_message_codec_test.cc.

442  {
443  decode_error_value("080500010203", FL_MESSAGE_CODEC_ERROR,
444  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
445 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA.

◆ TEST() [80/126]

TEST ( FlStandardMessageCodecTest  ,
DecodeUnknownType   
)

Definition at line 1090 of file fl_standard_message_codec_test.cc.

1090  {
1091  decode_error_value("0f", FL_MESSAGE_CODEC_ERROR,
1092  FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE);
1093 }
FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE
@ FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE
Definition: fl_message_codec.h:36

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE.

◆ TEST() [81/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeBoolFalse   
)

Definition at line 96 of file fl_standard_message_codec_test.cc.

96  {
97  g_autofree gchar* hex_string = encode_bool(FALSE);
98  EXPECT_STREQ(hex_string, "02");
99 }
encode_bool
static gchar * encode_bool(gboolean value)
Definition: fl_standard_message_codec_test.cc:91

References encode_bool().

◆ TEST() [82/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeBoolTrue   
)

Definition at line 101 of file fl_standard_message_codec_test.cc.

101  {
102  g_autofree gchar* hex_string = encode_bool(TRUE);
103  EXPECT_STREQ(hex_string, "01");
104 }
TRUE
return TRUE
Definition: fl_standard_message_codec_test.cc:1121

References encode_bool(), and TRUE.

◆ TEST() [83/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeCustomType   
)

Definition at line 1247 of file fl_standard_message_codec_test.cc.

1247  {
1248  g_autoptr(FlValue) value = fl_value_new_custom(128, "hello", nullptr);
1249  g_autoptr(FlTestStandardMessageCodec) codec =
1250  fl_test_standard_message_codec_new();
1251  g_autofree gchar* hex_string =
1252  encode_message_with_codec(value, FL_MESSAGE_CODEC(codec));
1253  EXPECT_STREQ(hex_string, "800568656c6c6f");
1254 }

References encode_message_with_codec(), fl_test_standard_message_codec_new(), fl_value_new_custom(), and value.

◆ TEST() [84/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeCustomTypes   
)

Definition at line 1256 of file fl_standard_message_codec_test.cc.

1256  {
1257  g_autoptr(FlValue) value = fl_value_new_list();
1258  fl_value_append_take(value, fl_value_new_custom(128, "hello", nullptr));
1259  fl_value_append_take(value, fl_value_new_custom(129, nullptr, nullptr));
1260  g_autoptr(FlTestStandardMessageCodec) codec =
1261  fl_test_standard_message_codec_new();
1262  g_autofree gchar* hex_string =
1263  encode_message_with_codec(value, FL_MESSAGE_CODEC(codec));
1264  EXPECT_STREQ(hex_string, "0c02800568656c6c6f81");
1265 }
fl_value_new_list
G_MODULE_EXPORT FlValue * fl_value_new_list()
Definition: fl_value.cc:349
fl_value_append_take
G_MODULE_EXPORT void fl_value_append_take(FlValue *self, FlValue *value)
Definition: fl_value.cc:600

References encode_message_with_codec(), fl_test_standard_message_codec_new(), fl_value_append_take(), fl_value_new_custom(), fl_value_new_list(), and value.

◆ TEST() [85/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeDecode   
)

Definition at line 1267 of file fl_standard_message_codec_test.cc.

1267  {
1268  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
1269 
1270  g_autoptr(FlValue) input = fl_value_new_list();
1271  fl_value_append_take(input, fl_value_new_null());
1272  fl_value_append_take(input, fl_value_new_bool(TRUE));
1273  fl_value_append_take(input, fl_value_new_int(42));
1274  fl_value_append_take(input, fl_value_new_float(M_PI));
1275  fl_value_append_take(input, fl_value_new_string("hello"));
1276  fl_value_append_take(input, fl_value_new_list());
1277  fl_value_append_take(input, fl_value_new_map());
1278 
1279  g_autoptr(GError) error = nullptr;
1280  g_autoptr(GBytes) message =
1281  fl_message_codec_encode_message(FL_MESSAGE_CODEC(codec), input, &error);
1282  EXPECT_NE(message, nullptr);
1283  EXPECT_EQ(error, nullptr);
1284 
1285  g_autoptr(FlValue) output =
1286  fl_message_codec_decode_message(FL_MESSAGE_CODEC(codec), message, &error);
1287  EXPECT_EQ(error, nullptr);
1288  EXPECT_NE(output, nullptr);
1289 
1290  ASSERT_TRUE(fl_value_equal(input, output));
1291 }
fl_value_new_null
G_MODULE_EXPORT FlValue * fl_value_new_null()
Definition: fl_value.cc:251
fl_value_equal
G_MODULE_EXPORT bool fl_value_equal(FlValue *a, FlValue *b)
Definition: fl_value.cc:471
fl_value_new_map
G_MODULE_EXPORT FlValue * fl_value_new_map()
Definition: fl_value.cc:366

References error, fl_message_codec_decode_message(), fl_message_codec_encode_message(), fl_standard_message_codec_new(), fl_value_append_take(), fl_value_equal(), fl_value_new_bool(), fl_value_new_float(), fl_value_new_int(), fl_value_new_list(), fl_value_new_map(), fl_value_new_null(), fl_value_new_string(), and TRUE.

◆ TEST() [86/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeDecodeLargeList   
)

Definition at line 786 of file fl_standard_message_codec_test.cc.

786  {
787  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
788 
789  g_autoptr(FlValue) value = fl_value_new_list();
790  for (int i = 0; i < 65535; i++) {
791  fl_value_append_take(value, fl_value_new_int(i));
792  }
793 
794  g_autoptr(GError) error = nullptr;
795  g_autoptr(GBytes) message =
796  fl_message_codec_encode_message(FL_MESSAGE_CODEC(codec), value, &error);
797  EXPECT_NE(message, nullptr);
798  EXPECT_EQ(error, nullptr);
799 
800  g_autoptr(FlValue) decoded_value =
801  fl_message_codec_decode_message(FL_MESSAGE_CODEC(codec), message, &error);
802  EXPECT_EQ(error, nullptr);
803  EXPECT_NE(value, nullptr);
804 
805  ASSERT_TRUE(fl_value_equal(value, decoded_value));
806 }

References error, fl_message_codec_decode_message(), fl_message_codec_encode_message(), fl_standard_message_codec_new(), fl_value_append_take(), fl_value_equal(), fl_value_new_int(), fl_value_new_list(), i, and value.

◆ TEST() [87/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeDecodeLargeMap   
)

Definition at line 1067 of file fl_standard_message_codec_test.cc.

1067  {
1068  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
1069 
1070  g_autoptr(FlValue) value = fl_value_new_map();
1071  for (int i = 0; i < 512; i++) {
1072  g_autofree gchar* key = g_strdup_printf("key%d", i);
1073  fl_value_set_string_take(value, key, fl_value_new_int(i));
1074  }
1075 
1076  g_autoptr(GError) error = nullptr;
1077  g_autoptr(GBytes) message =
1078  fl_message_codec_encode_message(FL_MESSAGE_CODEC(codec), value, &error);
1079  EXPECT_NE(message, nullptr);
1080  EXPECT_EQ(error, nullptr);
1081 
1082  g_autoptr(FlValue) decoded_value =
1083  fl_message_codec_decode_message(FL_MESSAGE_CODEC(codec), message, &error);
1084  EXPECT_EQ(error, nullptr);
1085  EXPECT_NE(value, nullptr);
1086 
1087  ASSERT_TRUE(fl_value_equal(value, decoded_value));
1088 }
fl_value_set_string_take
G_MODULE_EXPORT void fl_value_set_string_take(FlValue *self, const gchar *key, FlValue *value)
Definition: fl_value.cc:650

References error, fl_message_codec_decode_message(), fl_message_codec_encode_message(), fl_standard_message_codec_new(), fl_value_equal(), fl_value_new_int(), fl_value_new_map(), fl_value_set_string_take(), i, and value.

◆ TEST() [88/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloat32List   
)

Definition at line 563 of file fl_standard_message_codec_test.cc.

563  {
564  float data[] = {0.0f, -0.5f, 0.25f, -0.125f, 0.00625f};
565  g_autoptr(FlValue) value = fl_value_new_float32_list(data, 5);
566  g_autofree gchar* hex_string = encode_message(value);
567  EXPECT_STREQ(hex_string, "0e05000000000000000000bf0000803e000000becdcccc3b");
568 }
fl_value_new_float32_list
G_MODULE_EXPORT FlValue * fl_value_new_float32_list(const float *data, size_t data_length)
Definition: fl_value.cc:329

References encode_message(), fl_value_new_float32_list(), and value.

◆ TEST() [89/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloat32ListEmpty   
)

Definition at line 557 of file fl_standard_message_codec_test.cc.

557  {
558  g_autoptr(FlValue) value = fl_value_new_float32_list(nullptr, 0);
559  g_autofree gchar* hex_string = encode_message(value);
560  EXPECT_STREQ(hex_string, "0e000000");
561 }

References encode_message(), fl_value_new_float32_list(), and value.

◆ TEST() [90/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatFraction   
)

Definition at line 254 of file fl_standard_message_codec_test.cc.

254  {
255  g_autofree gchar* hex_string = encode_float(M_PI);
256  EXPECT_STREQ(hex_string, "0600000000000000182d4454fb210940");
257 }
encode_float
static gchar * encode_float(double value)
Definition: fl_standard_message_codec_test.cc:229

References encode_float().

◆ TEST() [91/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatHalf   
)

Definition at line 249 of file fl_standard_message_codec_test.cc.

249  {
250  g_autofree gchar* hex_string = encode_float(0.5);
251  EXPECT_STREQ(hex_string, "0600000000000000000000000000e03f");
252 }

References encode_float().

◆ TEST() [92/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatInfinity   
)

Definition at line 269 of file fl_standard_message_codec_test.cc.

269  {
270  g_autofree gchar* hex_string = encode_float(INFINITY);
271  EXPECT_STREQ(hex_string, "0600000000000000000000000000f07f");
272 }

References encode_float().

◆ TEST() [93/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatList   
)

Definition at line 615 of file fl_standard_message_codec_test.cc.

615  {
616  double data[] = {0, -0.5, 0.25, -0.125, 0.00625};
617  g_autoptr(FlValue) value = fl_value_new_float_list(data, 5);
618  g_autofree gchar* hex_string = encode_message(value);
619  EXPECT_STREQ(
620  hex_string,
621  "0b050000000000000000000000000000000000000000e0bf000000000000d03f00000000"
622  "0000c0bf9a9999999999793f");
623 }
fl_value_new_float_list
G_MODULE_EXPORT FlValue * fl_value_new_float_list(const double *data, size_t data_length)
Definition: fl_value.cc:339

References encode_message(), fl_value_new_float_list(), and value.

◆ TEST() [94/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatListEmpty   
)

Definition at line 609 of file fl_standard_message_codec_test.cc.

609  {
610  g_autoptr(FlValue) value = fl_value_new_float_list(nullptr, 0);
611  g_autofree gchar* hex_string = encode_message(value);
612  EXPECT_STREQ(hex_string, "0b00000000000000");
613 }

References encode_message(), fl_value_new_float_list(), and value.

◆ TEST() [95/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatMinusOne   
)

Definition at line 244 of file fl_standard_message_codec_test.cc.

244  {
245  g_autofree gchar* hex_string = encode_float(-1);
246  EXPECT_STREQ(hex_string, "0600000000000000000000000000f0bf");
247 }

References encode_float().

◆ TEST() [96/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatMinusZero   
)

Definition at line 259 of file fl_standard_message_codec_test.cc.

259  {
260  g_autofree gchar* hex_string = encode_float(-0.0);
261  EXPECT_STREQ(hex_string, "06000000000000000000000000000080");
262 }

References encode_float().

◆ TEST() [97/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatNaN   
)

Definition at line 264 of file fl_standard_message_codec_test.cc.

264  {
265  g_autofree gchar* hex_string = encode_float(NAN);
266  EXPECT_STREQ(hex_string, "0600000000000000000000000000f87f");
267 }

References encode_float().

◆ TEST() [98/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatOne   
)

Definition at line 239 of file fl_standard_message_codec_test.cc.

239  {
240  g_autofree gchar* hex_string = encode_float(1);
241  EXPECT_STREQ(hex_string, "0600000000000000000000000000f03f");
242 }

References encode_float().

◆ TEST() [99/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeFloatZero   
)

Definition at line 234 of file fl_standard_message_codec_test.cc.

234  {
235  g_autofree gchar* hex_string = encode_float(0);
236  EXPECT_STREQ(hex_string, "06000000000000000000000000000000");
237 }

References encode_float().

◆ TEST() [100/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt32   
)

Definition at line 121 of file fl_standard_message_codec_test.cc.

121  {
122  g_autofree gchar* hex_string = encode_int(0x01234567);
123  EXPECT_STREQ(hex_string, "0367452301");
124 }
encode_int
static gchar * encode_int(int64_t value)
Definition: fl_standard_message_codec_test.cc:106

References encode_int().

◆ TEST() [101/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt32List   
)

Definition at line 453 of file fl_standard_message_codec_test.cc.

453  {
454  int32_t data[] = {0, -1, 2, -3, 4};
455  g_autoptr(FlValue) value = fl_value_new_int32_list(data, 5);
456  g_autofree gchar* hex_string = encode_message(value);
457  EXPECT_STREQ(hex_string, "0905000000000000ffffffff02000000fdffffff04000000");
458 }
fl_value_new_int32_list
G_MODULE_EXPORT FlValue * fl_value_new_int32_list(const int32_t *data, size_t data_length)
Definition: fl_value.cc:309

References encode_message(), fl_value_new_int32_list(), and value.

◆ TEST() [102/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt32ListEmpty   
)

Definition at line 447 of file fl_standard_message_codec_test.cc.

447  {
448  g_autoptr(FlValue) value = fl_value_new_int32_list(nullptr, 0);
449  g_autofree gchar* hex_string = encode_message(value);
450  EXPECT_STREQ(hex_string, "09000000");
451 }

References encode_message(), fl_value_new_int32_list(), and value.

◆ TEST() [103/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt32Max   
)

Definition at line 131 of file fl_standard_message_codec_test.cc.

131  {
132  g_autofree gchar* hex_string = encode_int(G_MAXINT32);
133  EXPECT_STREQ(hex_string, "03ffffff7f");
134 }

References encode_int().

◆ TEST() [104/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt32Min   
)

Definition at line 126 of file fl_standard_message_codec_test.cc.

126  {
127  g_autofree gchar* hex_string = encode_int(G_MININT32);
128  EXPECT_STREQ(hex_string, "0300000080");
129 }

References encode_int().

◆ TEST() [105/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt64   
)

Definition at line 136 of file fl_standard_message_codec_test.cc.

136  {
137  g_autofree gchar* hex_string = encode_int(0x0123456789abcdef);
138  EXPECT_STREQ(hex_string, "04efcdab8967452301");
139 }

References encode_int().

◆ TEST() [106/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt64List   
)

Definition at line 505 of file fl_standard_message_codec_test.cc.

505  {
506  int64_t data[] = {0, -1, 2, -3, 4};
507  g_autoptr(FlValue) value = fl_value_new_int64_list(data, 5);
508  g_autofree gchar* hex_string = encode_message(value);
509  EXPECT_STREQ(
510  hex_string,
511  "0a050000000000000000000000000000ffffffffffffffff0200000000000000fdffffff"
512  "ffffffff0400000000000000");
513 }
fl_value_new_int64_list
G_MODULE_EXPORT FlValue * fl_value_new_int64_list(const int64_t *data, size_t data_length)
Definition: fl_value.cc:319

References encode_message(), fl_value_new_int64_list(), and value.

◆ TEST() [107/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt64ListEmpty   
)

Definition at line 499 of file fl_standard_message_codec_test.cc.

499  {
500  g_autoptr(FlValue) value = fl_value_new_int64_list(nullptr, 0);
501  g_autofree gchar* hex_string = encode_message(value);
502  EXPECT_STREQ(hex_string, "0a00000000000000");
503 }

References encode_message(), fl_value_new_int64_list(), and value.

◆ TEST() [108/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt64Max   
)

Definition at line 146 of file fl_standard_message_codec_test.cc.

146  {
147  g_autofree gchar* hex_string = encode_int(G_MAXINT64);
148  EXPECT_STREQ(hex_string, "04ffffffffffffff7f");
149 }

References encode_int().

◆ TEST() [109/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeInt64Min   
)

Definition at line 141 of file fl_standard_message_codec_test.cc.

141  {
142  g_autofree gchar* hex_string = encode_int(G_MININT64);
143  EXPECT_STREQ(hex_string, "040000000000000080");
144 }

References encode_int().

◆ TEST() [110/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeIntOne   
)

Definition at line 116 of file fl_standard_message_codec_test.cc.

116  {
117  g_autofree gchar* hex_string = encode_int(1);
118  EXPECT_STREQ(hex_string, "0301000000");
119 }

References encode_int().

◆ TEST() [111/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeIntZero   
)

Definition at line 111 of file fl_standard_message_codec_test.cc.

111  {
112  g_autofree gchar* hex_string = encode_int(0);
113  EXPECT_STREQ(hex_string, "0300000000");
114 }

References encode_int().

◆ TEST() [112/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeListEmpty   
)

Definition at line 667 of file fl_standard_message_codec_test.cc.

667  {
668  g_autoptr(FlValue) value = fl_value_new_list();
669  g_autofree gchar* hex_string = encode_message(value);
670  EXPECT_STREQ(hex_string, "0c00");
671 }

References encode_message(), fl_value_new_list(), and value.

◆ TEST() [113/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeListNested   
)

Definition at line 688 of file fl_standard_message_codec_test.cc.

688  {
689  g_autoptr(FlValue) even_numbers = fl_value_new_list();
690  g_autoptr(FlValue) odd_numbers = fl_value_new_list();
691  for (int i = 0; i < 10; i++) {
692  if (i % 2 == 0) {
693  fl_value_append_take(even_numbers, fl_value_new_int(i));
694  } else {
695  fl_value_append_take(odd_numbers, fl_value_new_int(i));
696  }
697  }
698  g_autoptr(FlValue) value = fl_value_new_list();
699  fl_value_append(value, even_numbers);
700  fl_value_append(value, odd_numbers);
701  g_autofree gchar* hex_string = encode_message(value);
702  EXPECT_STREQ(hex_string,
703  "0c020c05030000000003020000000304000000030600000003080000000c"
704  "0503010000000303000000030500000003070000000309000000");
705 }
fl_value_append
G_MODULE_EXPORT void fl_value_append(FlValue *self, FlValue *value)
Definition: fl_value.cc:592

References encode_message(), fl_value_append(), fl_value_append_take(), fl_value_new_int(), fl_value_new_list(), i, and value.

◆ TEST() [114/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeListTypes   
)

Definition at line 673 of file fl_standard_message_codec_test.cc.

673  {
674  g_autoptr(FlValue) value = fl_value_new_list();
675  fl_value_append_take(value, fl_value_new_null());
676  fl_value_append_take(value, fl_value_new_bool(TRUE));
677  fl_value_append_take(value, fl_value_new_int(42));
678  fl_value_append_take(value, fl_value_new_float(M_PI));
679  fl_value_append_take(value, fl_value_new_string("hello"));
680  fl_value_append_take(value, fl_value_new_list());
681  fl_value_append_take(value, fl_value_new_map());
682  g_autofree gchar* hex_string = encode_message(value);
683  EXPECT_STREQ(
684  hex_string,
685  "0c070001032a00000006000000000000182d4454fb210940070568656c6c6f0c000d00");
686 }

References encode_message(), fl_value_append_take(), fl_value_new_bool(), fl_value_new_float(), fl_value_new_int(), fl_value_new_list(), fl_value_new_map(), fl_value_new_null(), fl_value_new_string(), TRUE, and value.

◆ TEST() [115/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeMapEmpty   
)

Definition at line 808 of file fl_standard_message_codec_test.cc.

808  {
809  g_autoptr(FlValue) value = fl_value_new_map();
810  g_autofree gchar* hex_string = encode_message(value);
811  EXPECT_STREQ(hex_string, "0d00");
812 }

References encode_message(), fl_value_new_map(), and value.

◆ TEST() [116/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeMapKeyTypes   
)

Definition at line 814 of file fl_standard_message_codec_test.cc.

814  {
815  g_autoptr(FlValue) value = fl_value_new_map();
816  fl_value_set_take(value, fl_value_new_null(), fl_value_new_string("null"));
817  fl_value_set_take(value, fl_value_new_bool(TRUE),
818  fl_value_new_string("bool"));
819  fl_value_set_take(value, fl_value_new_int(42), fl_value_new_string("int"));
820  fl_value_set_take(value, fl_value_new_float(M_PI),
821  fl_value_new_string("float"));
822  fl_value_set_take(value, fl_value_new_string("hello"),
823  fl_value_new_string("string"));
824  fl_value_set_take(value, fl_value_new_list(), fl_value_new_string("list"));
825  fl_value_set_take(value, fl_value_new_map(), fl_value_new_string("map"));
826  g_autofree gchar* hex_string = encode_message(value);
827  EXPECT_STREQ(hex_string,
828  "0d070007046e756c6c010704626f6f6c032a0000000703696e7406000000000"
829  "0182d4454fb2109400705666c6f6174070568656c6c6f0706737472696e670c"
830  "0007046c6973740d0007036d6170");
831 }
fl_value_set_take
G_MODULE_EXPORT void fl_value_set_take(FlValue *self, FlValue *key, FlValue *value)
Definition: fl_value.cc:618

References encode_message(), fl_value_new_bool(), fl_value_new_float(), fl_value_new_int(), fl_value_new_list(), fl_value_new_map(), fl_value_new_null(), fl_value_new_string(), fl_value_set_take(), TRUE, and value.

◆ TEST() [117/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeMapNested   
)

Definition at line 852 of file fl_standard_message_codec_test.cc.

852  {
853  g_autoptr(FlValue) str_to_int = fl_value_new_map();
854  g_autoptr(FlValue) int_to_str = fl_value_new_map();
855  const char* numbers[] = {"zero", "one", "two", "three", nullptr};
856  for (int i = 0; numbers[i] != nullptr; i++) {
857  fl_value_set_take(str_to_int, fl_value_new_string(numbers[i]),
858  fl_value_new_int(i));
859  fl_value_set_take(int_to_str, fl_value_new_int(i),
860  fl_value_new_string(numbers[i]));
861  }
862  g_autoptr(FlValue) value = fl_value_new_map();
863  fl_value_set_string(value, "str-to-int", str_to_int);
864  fl_value_set_string(value, "int-to-str", int_to_str);
865  g_autofree gchar* hex_string = encode_message(value);
866  EXPECT_STREQ(hex_string,
867  "0d02070a7374722d746f2d696e740d0407047a65726f030000000007036f6e6"
868  "50301000000070374776f0302000000070574687265650303000000070a696e"
869  "742d746f2d7374720d04030000000007047a65726f030100000007036f6e650"
870  "302000000070374776f030300000007057468726565");
871 }
fl_value_set_string
G_MODULE_EXPORT void fl_value_set_string(FlValue *self, const gchar *key, FlValue *value)
Definition: fl_value.cc:639

References encode_message(), fl_value_new_int(), fl_value_new_map(), fl_value_new_string(), fl_value_set_string(), fl_value_set_take(), i, and value.

◆ TEST() [118/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeMapValueTypes   
)

Definition at line 833 of file fl_standard_message_codec_test.cc.

833  {
834  g_autoptr(FlValue) value = fl_value_new_map();
835  fl_value_set_take(value, fl_value_new_string("null"), fl_value_new_null());
836  fl_value_set_take(value, fl_value_new_string("bool"),
837  fl_value_new_bool(TRUE));
838  fl_value_set_take(value, fl_value_new_string("int"), fl_value_new_int(42));
839  fl_value_set_take(value, fl_value_new_string("float"),
840  fl_value_new_float(M_PI));
841  fl_value_set_take(value, fl_value_new_string("string"),
842  fl_value_new_string("hello"));
843  fl_value_set_take(value, fl_value_new_string("list"), fl_value_new_list());
844  fl_value_set_take(value, fl_value_new_string("map"), fl_value_new_map());
845  g_autofree gchar* hex_string = encode_message(value);
846  EXPECT_STREQ(hex_string,
847  "0d0707046e756c6c000704626f6f6c010703696e74032a0000000705666c6f6"
848  "17406000000000000182d4454fb2109400706737472696e67070568656c6c6f"
849  "07046c6973740c0007036d61700d00");
850 }

References encode_message(), fl_value_new_bool(), fl_value_new_float(), fl_value_new_int(), fl_value_new_list(), fl_value_new_map(), fl_value_new_null(), fl_value_new_string(), fl_value_set_take(), TRUE, and value.

◆ TEST() [119/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeNull   
)

Definition at line 72 of file fl_standard_message_codec_test.cc.

72  {
73  g_autoptr(FlValue) value = fl_value_new_null();
74  g_autofree gchar* hex_string = encode_message(value);
75  EXPECT_STREQ(hex_string, "00");
76 }

References encode_message(), fl_value_new_null(), and value.

◆ TEST() [120/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeNullptr   
)

Definition at line 67 of file fl_standard_message_codec_test.cc.

67  {
68  g_autofree gchar* hex_string = encode_message(nullptr);
69  EXPECT_STREQ(hex_string, "00");
70 }

References encode_message().

◆ TEST() [121/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeStringEmpty   
)

Definition at line 342 of file fl_standard_message_codec_test.cc.

342  {
343  g_autofree gchar* hex_string = encode_string("");
344  EXPECT_STREQ(hex_string, "0700");
345 }
encode_string
static gchar * encode_string(const gchar *value)
Definition: fl_standard_message_codec_test.cc:337

References encode_string().

◆ TEST() [122/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeStringEmptySized   
)

Definition at line 352 of file fl_standard_message_codec_test.cc.

352  {
353  g_autoptr(FlValue) value = fl_value_new_string_sized(nullptr, 0);
354  g_autofree gchar* hex_string = encode_message(value);
355  EXPECT_STREQ(hex_string, "0700");
356 }
fl_value_new_string_sized
G_MODULE_EXPORT FlValue * fl_value_new_string_sized(const gchar *value, size_t value_length)
Definition: fl_value.cc:283

References encode_message(), fl_value_new_string_sized(), and value.

◆ TEST() [123/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeStringHello   
)

Definition at line 347 of file fl_standard_message_codec_test.cc.

347  {
348  g_autofree gchar* hex_string = encode_string("hello");
349  EXPECT_STREQ(hex_string, "070568656c6c6f");
350 }

References encode_string().

◆ TEST() [124/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeStringHelloSized   
)

Definition at line 358 of file fl_standard_message_codec_test.cc.

358  {
359  g_autoptr(FlValue) value = fl_value_new_string_sized("Hello World", 5);
360  g_autofree gchar* hex_string = encode_message(value);
361  EXPECT_STREQ(hex_string, "070548656c6c6f");
362 }

References encode_message(), fl_value_new_string_sized(), and value.

◆ TEST() [125/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeUint8List   
)

Definition at line 402 of file fl_standard_message_codec_test.cc.

402  {
403  uint8_t data[] = {0, 1, 2, 3, 4};
404  g_autoptr(FlValue) value = fl_value_new_uint8_list(data, 5);
405  g_autofree gchar* hex_string = encode_message(value);
406  EXPECT_STREQ(hex_string, "08050001020304");
407 }
fl_value_new_uint8_list
G_MODULE_EXPORT FlValue * fl_value_new_uint8_list(const uint8_t *data, size_t data_length)
Definition: fl_value.cc:292

References encode_message(), fl_value_new_uint8_list(), and value.

◆ TEST() [126/126]

TEST ( FlStandardMessageCodecTest  ,
EncodeUint8ListEmpty   
)

Definition at line 396 of file fl_standard_message_codec_test.cc.

396  {
397  g_autoptr(FlValue) value = fl_value_new_uint8_list(nullptr, 0);
398  g_autofree gchar* hex_string = encode_message(value);
399  EXPECT_STREQ(hex_string, "0800");
400 }

References encode_message(), fl_value_new_uint8_list(), and value.

◆ write_custom_value2()

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

Definition at line 1124 of file fl_standard_message_codec_test.cc.

1127  {
1128  uint8_t type = 129;
1129  g_byte_array_append(buffer, &type, sizeof(uint8_t));
1130  return TRUE;
1131 }
g_byte_array_append
g_byte_array_append(buffer, &type, sizeof(uint8_t))

References buffer, g_byte_array_append(), TRUE, and type.

Referenced by fl_test_standard_message_codec_write_value().

Variable Documentation

◆ buffer

GByteArray* buffer

Definition at line 1110 of file fl_standard_message_codec_test.cc.

Referenced by fl_test_standard_message_codec_read_value_of_type(), fl_test_standard_message_codec_write_value(), read_custom_value1(), and write_custom_value2().

◆ error

GByteArray FlValue GError** error
Initial value:
{
const gchar* text =
static_cast<const gchar*>(fl_value_get_custom_value(value))

Definition at line 1112 of file fl_standard_message_codec_test.cc.

Referenced by decode_error_value(), decode_message_with_codec(), encode_message_with_codec(), fl_test_standard_message_codec_read_value_of_type(), fl_test_standard_message_codec_write_value(), read_custom_value1(), and TEST().

◆ length

size_t length = strlen(text)

Definition at line 1115 of file fl_standard_message_codec_test.cc.

Referenced by fl_accessible_text_field_insert_text(), fl_json_method_codec_decode_response(), fl_standard_message_codec_real_write_value(), fl_value_new_uint8_list_from_bytes(), flutter::GetExecutableDirectory(), FlValueHandler::Key(), read_custom_value1(), read_float32_list_value(), read_float64_list_value(), read_int32_list_value(), read_int64_list_value(), read_list_value(), read_map_value(), read_string_value(), read_uint8_list_value(), flutter::ByteBufferStreamReader::ReadBytes(), flutter::StandardCodecSerializer::ReadValueOfType(), FlValueHandler::String(), synchronize_pressed_states(), and flutter::ByteBufferStreamWriter::WriteBytes().

◆ TRUE

return TRUE

Definition at line 1121 of file fl_standard_message_codec_test.cc.

Referenced by TEST(), and write_custom_value2().

◆ type

uint8_t type = 128

Definition at line 1117 of file fl_standard_message_codec_test.cc.

Referenced by fl_key_channel_responder_handle_event(), fl_key_event_channel_send(), fl_key_event_new_from_gdk_event(), fl_platform_channel_system_request_app_exit(), fl_standard_message_codec_read_value(), fl_standard_message_codec_read_value_of_type(), fl_standard_method_codec_decode_response(), fl_standard_method_codec_encode_error_envelope(), fl_standard_method_codec_encode_success_envelope(), fl_test_standard_message_codec_read_value_of_type(), fl_value_new(), fl_value_new_custom(), fl_value_new_custom_object(), fl_value_new_custom_object_take(), G_DECLARE_DERIVABLE_TYPE(), flutter::StandardCodecSerializer::ReadValue(), flutter::StandardCodecSerializer::ReadValueOfType(), request_app_exit(), synchronize_lock_states(), synthesize_simple_event(), system_exit_application(), system_sound_play(), TEST(), and write_custom_value2().

◆ value

GByteArray FlValue* value

Definition at line 1111 of file fl_standard_message_codec_test.cc.

Referenced by decode_error_value(), decode_message_with_codec(), encode_bool(), encode_float(), encode_int(), encode_message(), encode_message_with_codec(), encode_string(), fl_test_standard_message_codec_write_value(), read_custom_value1(), and TEST().