| 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 "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 53 of file fl_standard_message_codec_test.cc.

55 {
56 g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
57 g_autoptr(GBytes) data = hex_string_to_bytes(hex_string);
58 g_autoptr(GError) error = nullptr;
59 g_autoptr(FlValue) value =
60 fl_message_codec_decode_message(FL_MESSAGE_CODEC(codec), data, &error);
61 EXPECT_TRUE(value == nullptr);
62 EXPECT_TRUE(g_error_matches(error, domain, code));
63 }

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 46 of file fl_standard_message_codec_test.cc.

46 {
47 g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
48 return decode_message_with_codec(hex_string, FL_MESSAGE_CODEC(codec));
49 }

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 33 of file fl_standard_message_codec_test.cc.

34 {
35 g_autoptr(GBytes) data = hex_string_to_bytes(hex_string);
36 g_autoptr(GError) error = nullptr;
37 g_autoptr(FlValue) value =
38 fl_message_codec_decode_message(codec, data, &error);
39 EXPECT_EQ(error, nullptr);
40 EXPECT_NE(value, nullptr);
41 return fl_value_ref(value);
42 }

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 89 of file fl_standard_message_codec_test.cc.

89 {
90 g_autoptr(FlValue) v = fl_value_new_bool(value);
91 return encode_message(v);
92 }

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

Referenced by TEST().

## ◆ encode_float()

static gchar* encode_float | ( | double | value | ) |
| static

Definition at line 227 of file fl_standard_message_codec_test.cc.

227 {
228 g_autoptr(FlValue) v = fl_value_new_float(value);
229 return encode_message(v);
230 }

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 104 of file fl_standard_message_codec_test.cc.

104 {
105 g_autoptr(FlValue) v = fl_value_new_int(value);
106 return encode_message(v);
107 }

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

Referenced by TEST().

## ◆ encode_message()

static gchar* encode_message | ( | FlValue * | value | ) |
| static

Definition at line 26 of file fl_standard_message_codec_test.cc.

26 {
27 g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
28 return encode_message_with_codec(value, FL_MESSAGE_CODEC(codec));
29 }

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 14 of file fl_standard_message_codec_test.cc.

14 {
15 g_autoptr(GError) error = nullptr;
16 g_autoptr(GBytes) message =
17 fl_message_codec_encode_message(codec, value, &error);
18 EXPECT_NE(message, nullptr);
19 EXPECT_EQ(error, nullptr);
20
21 return bytes_to_hex_string(message);
22 }

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 335 of file fl_standard_message_codec_test.cc.

335 {
336 g_autoptr(FlValue) v = fl_value_new_string(value);
337 return encode_message(v);
338 }

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 1198 of file fl_standard_message_codec_test.cc.

1199 {
1200 FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->write_value =
1201 fl_test_standard_message_codec_write_value;
1202 FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->read_value_of_type =
1203 fl_test_standard_message_codec_read_value_of_type;
1204 }

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 1206 of file fl_standard_message_codec_test.cc.

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

## ◆ fl_test_standard_message_codec_new()

static FlTestStandardMessageCodec* fl_test_standard_message_codec_new | ( |  | ) |
| static

Definition at line 1212 of file fl_standard_message_codec_test.cc.

1212 {
1213 return FL_TEST_STANDARD_MESSAGE_CODEC(
1214 g_object_new(fl_test_standard_message_codec_get_type(), nullptr));
1215 }

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 1181 of file fl_standard_message_codec_test.cc.

1186 {
1187 if (type == 128) {
1188 return read_custom_value1(codec, buffer, offset, error);
1189 } else if (type == 129) {
1190 return read_custom_value2(codec, buffer, offset, error);
1191 } else {
1192 return FL_STANDARD_MESSAGE_CODEC_CLASS(
1193 fl_test_standard_message_codec_parent_class)
1194 ->read_value_of_type(codec, buffer, offset, type, error);
1195 }
1196 }

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 1131 of file fl_standard_message_codec_test.cc.

1135 {
1136 if (fl_value_get_type(value) == FL_VALUE_TYPE_CUSTOM &&
1137 fl_value_get_custom_type(value) == 128) {
1138 return write_custom_value1(codec, buffer, value, error);
1139 } else if (fl_value_get_type(value) == FL_VALUE_TYPE_CUSTOM &&
1140 fl_value_get_custom_type(value) == 129) {
1141 return write_custom_value2(codec, buffer, value, error);
1142 } else {
1143 return FL_STANDARD_MESSAGE_CODEC_CLASS(
1144 fl_test_standard_message_codec_parent_class)
1145 ->write_value(codec, buffer, value, error);
1146 }
1147 }

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 1093 of file fl_standard_message_codec_test.cc.

1099 {
1100 FlStandardMessageCodec parent_instance;
1101 };

## ◆ 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 1149 of file fl_standard_message_codec_test.cc.

1152 {
1153 uint32_t length;
1154 if (!fl_standard_message_codec_read_size(codec, buffer, offset, &length,
1155 error)) {
1156 return nullptr;
1157 }
1158 if (*offset + length > g_bytes_get_size(buffer)) {
1159 g_set_error(error, FL_MESSAGE_CODEC_ERROR,
1160 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA, "Unexpected end of data");
1161 return nullptr;
1162 }
1163 FlValue* value = fl_value_new_custom(
1164 128,
1165 g_strndup(static_cast<const gchar*>(g_bytes_get_data(buffer, nullptr)) +
1166 *offset,
1167 length),
1168 g_free);
1169 *offset += length;
1170
1171 return value;
1172 }

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 1174 of file fl_standard_message_codec_test.cc.

1177 {
1178 return fl_value_new_custom(129, nullptr, nullptr);
1179 }

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 1217 of file fl_standard_message_codec_test.cc.

1217 {
1218 g_autoptr(FlTestStandardMessageCodec) codec =
1219 fl_test_standard_message_codec_new();
1220 g_autoptr(FlValue) value =
1221 decode_message_with_codec("800568656c6c6f", FL_MESSAGE_CODEC(codec));
1222 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_CUSTOM);
1223 ASSERT_EQ(fl_value_get_custom_type(value), 128);
1224 EXPECT_STREQ(static_cast<const gchar*>(fl_value_get_custom_value(value)),
1225 "hello");
1226 }

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 1228 of file fl_standard_message_codec_test.cc.

1228 {
1229 g_autoptr(FlTestStandardMessageCodec) codec =
1230 fl_test_standard_message_codec_new();
1231 g_autoptr(FlValue) value = decode_message_with_codec("0c02800568656c6c6f81",
1232 FL_MESSAGE_CODEC(codec));
1233 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_LIST);
1234 EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(2));
1235 FlValue* value1 = fl_value_get_list_value(value, 0);
1236 ASSERT_EQ(fl_value_get_type(value1), FL_VALUE_TYPE_CUSTOM);
1237 ASSERT_EQ(fl_value_get_custom_type(value1), 128);
1238 EXPECT_STREQ(static_cast<const gchar*>(fl_value_get_custom_value(value1)),
1239 "hello");
1240 FlValue* value2 = fl_value_get_list_value(value, 1);
1241 ASSERT_EQ(fl_value_get_type(value2), FL_VALUE_TYPE_CUSTOM);
1242 ASSERT_EQ(fl_value_get_custom_type(value2), 129);
1243 }

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 574 of file fl_standard_message_codec_test.cc.

574 {
575 g_autoptr(FlValue) value =
576 decode_message("0e05000000000000000000bf0000803e000000becdcccc3b");
577 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT32_LIST);
578 const float* data = fl_value_get_float32_list(value);
579 EXPECT_FLOAT_EQ(data[0], 0.0f);
580 EXPECT_FLOAT_EQ(data[1], -0.5f);
581 EXPECT_FLOAT_EQ(data[2], 0.25f);
582 EXPECT_FLOAT_EQ(data[3], -0.125f);
583 EXPECT_FLOAT_EQ(data[4], 0.00625f);
584 }

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 568 of file fl_standard_message_codec_test.cc.

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

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 591 of file fl_standard_message_codec_test.cc.

591 {
592 decode_error_value("0e050000", FL_MESSAGE_CODEC_ERROR,
593 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
594 }

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 586 of file fl_standard_message_codec_test.cc.

586 {
587 decode_error_value("0e", FL_MESSAGE_CODEC_ERROR,
588 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
589 }

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 596 of file fl_standard_message_codec_test.cc.

596 {
597 decode_error_value("0e05000000", FL_MESSAGE_CODEC_ERROR,
598 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
599 }

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 601 of file fl_standard_message_codec_test.cc.

601 {
602 decode_error_value("0e05000000000000000000bf0000803e000000becdcccc",
603 FL_MESSAGE_CODEC_ERROR,
604 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
605 }

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 290 of file fl_standard_message_codec_test.cc.

290 {
291 g_autoptr(FlValue) value = decode_message("0600000000000000000000000000e03f");
292 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
293 EXPECT_EQ(fl_value_get_float(value), 0.5);
294 }

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 314 of file fl_standard_message_codec_test.cc.

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

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 629 of file fl_standard_message_codec_test.cc.

629 {
630 g_autoptr(FlValue) value = decode_message(
631 "0b050000000000000000000000000000000000000000e0bf000000000000d03f00000000"
632 "0000c0bf9a9999999999793f");
633 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT_LIST);
634 const double* data = fl_value_get_float_list(value);
635 EXPECT_FLOAT_EQ(data[0], 0.0);
636 EXPECT_FLOAT_EQ(data[1], -0.5);
637 EXPECT_FLOAT_EQ(data[2], 0.25);
638 EXPECT_FLOAT_EQ(data[3], -0.125);
639 EXPECT_FLOAT_EQ(data[4], 0.00625);
640 }

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 623 of file fl_standard_message_codec_test.cc.

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

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 647 of file fl_standard_message_codec_test.cc.

647 {
648 decode_error_value("0b05000000000000", FL_MESSAGE_CODEC_ERROR,
649 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
650 }

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 642 of file fl_standard_message_codec_test.cc.

642 {
643 decode_error_value("0b", FL_MESSAGE_CODEC_ERROR,
644 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
645 }

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 652 of file fl_standard_message_codec_test.cc.

652 {
653 decode_error_value("0b0500000000000000", FL_MESSAGE_CODEC_ERROR,
654 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
655 }

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 657 of file fl_standard_message_codec_test.cc.

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

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 284 of file fl_standard_message_codec_test.cc.

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

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 302 of file fl_standard_message_codec_test.cc.

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

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 308 of file fl_standard_message_codec_test.cc.

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

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 320 of file fl_standard_message_codec_test.cc.

320 {
321 decode_error_value("060000000000000000", FL_MESSAGE_CODEC_ERROR,
322 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
323 }

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 278 of file fl_standard_message_codec_test.cc.

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

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 296 of file fl_standard_message_codec_test.cc.

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

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 325 of file fl_standard_message_codec_test.cc.

325 {
326 decode_error_value("060000000000000000", FL_MESSAGE_CODEC_ERROR,
327 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
328 }

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 330 of file fl_standard_message_codec_test.cc.

330 {
331 decode_error_value("060000000000000000000000000000", FL_MESSAGE_CODEC_ERROR,
332 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
333 }

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 272 of file fl_standard_message_codec_test.cc.

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

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 161 of file fl_standard_message_codec_test.cc.

161 {
162 g_autoptr(FlValue) value = decode_message("0367452301");
163 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
164 EXPECT_EQ(fl_value_get_int(value), 0x01234567);
165 }

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 464 of file fl_standard_message_codec_test.cc.

464 {
465 g_autoptr(FlValue) value =
466 decode_message("0905000000000000ffffffff02000000fdffffff04000000");
467 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT32_LIST);
468 const int32_t* data = fl_value_get_int32_list(value);
469 EXPECT_EQ(data[0], 0);
470 EXPECT_EQ(data[1], -1);
471 EXPECT_EQ(data[2], 2);
472 EXPECT_EQ(data[3], -3);
473 EXPECT_EQ(data[4], 4);
474 }

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 458 of file fl_standard_message_codec_test.cc.

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

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 481 of file fl_standard_message_codec_test.cc.

481 {
482 decode_error_value("09050000", FL_MESSAGE_CODEC_ERROR,
483 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
484 }

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 476 of file fl_standard_message_codec_test.cc.

476 {
477 decode_error_value("09", FL_MESSAGE_CODEC_ERROR,
478 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
479 }

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 486 of file fl_standard_message_codec_test.cc.

486 {
487 decode_error_value("0905000000", FL_MESSAGE_CODEC_ERROR,
488 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
489 }

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 491 of file fl_standard_message_codec_test.cc.

491 {
492 decode_error_value("090500000000ffffffff02000000fdffffff040000",
493 FL_MESSAGE_CODEC_ERROR,
494 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
495 }

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 173 of file fl_standard_message_codec_test.cc.

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

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 167 of file fl_standard_message_codec_test.cc.

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

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 197 of file fl_standard_message_codec_test.cc.

197 {
198 decode_error_value("03", FL_MESSAGE_CODEC_ERROR,
199 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
200 }

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 179 of file fl_standard_message_codec_test.cc.

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

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 519 of file fl_standard_message_codec_test.cc.

519 {
520 g_autoptr(FlValue) value = decode_message(
521 "0a050000000000000000000000000000ffffffffffffffff0200000000000000fdffffff"
522 "ffffffff0400000000000000");
523 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT64_LIST);
524 const int64_t* data = fl_value_get_int64_list(value);
525 EXPECT_EQ(data[0], 0);
526 EXPECT_EQ(data[1], -1);
527 EXPECT_EQ(data[2], 2);
528 EXPECT_EQ(data[3], -3);
529 EXPECT_EQ(data[4], 4);
530 }

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 513 of file fl_standard_message_codec_test.cc.

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

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 537 of file fl_standard_message_codec_test.cc.

537 {
538 decode_error_value("0a05000000000000", FL_MESSAGE_CODEC_ERROR,
539 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
540 }

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 532 of file fl_standard_message_codec_test.cc.

532 {
533 decode_error_value("0a", FL_MESSAGE_CODEC_ERROR,
534 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
535 }

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 542 of file fl_standard_message_codec_test.cc.

542 {
543 decode_error_value("0a0500000000000000", FL_MESSAGE_CODEC_ERROR,
544 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
545 }

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 547 of file fl_standard_message_codec_test.cc.

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

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 191 of file fl_standard_message_codec_test.cc.

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

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 185 of file fl_standard_message_codec_test.cc.

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

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 212 of file fl_standard_message_codec_test.cc.

212 {
213 decode_error_value("04", FL_MESSAGE_CODEC_ERROR,
214 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
215 }

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 217 of file fl_standard_message_codec_test.cc.

217 {
218 decode_error_value("04ef", FL_MESSAGE_CODEC_ERROR,
219 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
220 }

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 222 of file fl_standard_message_codec_test.cc.

222 {
223 decode_error_value("04efcdab89674523", FL_MESSAGE_CODEC_ERROR,
224 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
225 }

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 155 of file fl_standard_message_codec_test.cc.

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

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 202 of file fl_standard_message_codec_test.cc.

202 {
203 decode_error_value("0367", FL_MESSAGE_CODEC_ERROR,
204 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
205 }

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 207 of file fl_standard_message_codec_test.cc.

207 {
208 decode_error_value("03674523", FL_MESSAGE_CODEC_ERROR,
209 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
210 }

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 149 of file fl_standard_message_codec_test.cc.

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

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 705 of file fl_standard_message_codec_test.cc.

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

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 768 of file fl_standard_message_codec_test.cc.

768 {
769 decode_error_value("0c07", FL_MESSAGE_CODEC_ERROR,
770 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
771 }

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 740 of file fl_standard_message_codec_test.cc.

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

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 763 of file fl_standard_message_codec_test.cc.

763 {
764 decode_error_value("0c", FL_MESSAGE_CODEC_ERROR,
765 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
766 }

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 773 of file fl_standard_message_codec_test.cc.

773 {
774 decode_error_value("0c0700", FL_MESSAGE_CODEC_ERROR,
775 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
776 }

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 778 of file fl_standard_message_codec_test.cc.

778 {
779 decode_error_value(
780 "0c070001032a00000006000000000000182d4454fb210940070568656c6c6f0c000d",
781 FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
782 }

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 711 of file fl_standard_message_codec_test.cc.

711 {
712 g_autoptr(FlValue) value = decode_message(
713 "0c070001032a00000006000000000000182d4454fb210940070568656c6c6f0c000d00");
714 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_LIST);
715 ASSERT_EQ(fl_value_get_length(value), static_cast<size_t>(7));
716 ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 0)),
717 FL_VALUE_TYPE_NULL);
718 ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 1)),
719 FL_VALUE_TYPE_BOOL);
720 EXPECT_TRUE(fl_value_get_bool(fl_value_get_list_value(value, 1)));
721 ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 2)),
722 FL_VALUE_TYPE_INT);
723 EXPECT_EQ(fl_value_get_int(fl_value_get_list_value(value, 2)), 42);
724 ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 3)),
725 FL_VALUE_TYPE_FLOAT);
726 EXPECT_FLOAT_EQ(fl_value_get_float(fl_value_get_list_value(value, 3)), M_PI);
727 ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 4)),
728 FL_VALUE_TYPE_STRING);
729 EXPECT_STREQ(fl_value_get_string(fl_value_get_list_value(value, 4)), "hello");
730 ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 5)),
731 FL_VALUE_TYPE_LIST);
732 ASSERT_EQ(fl_value_get_length(fl_value_get_list_value(value, 5)),
733 static_cast<size_t>(0));
734 ASSERT_EQ(fl_value_get_type(fl_value_get_list_value(value, 6)),
735 FL_VALUE_TYPE_MAP);
736 ASSERT_EQ(fl_value_get_length(fl_value_get_list_value(value, 6)),
737 static_cast<size_t>(0));
738 }

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 871 of file fl_standard_message_codec_test.cc.

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

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 877 of file fl_standard_message_codec_test.cc.

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

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 1047 of file fl_standard_message_codec_test.cc.

1047 {
1048 decode_error_value("0d07", FL_MESSAGE_CODEC_ERROR,
1049 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
1050 }

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 995 of file fl_standard_message_codec_test.cc.

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

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 1042 of file fl_standard_message_codec_test.cc.

1042 {
1043 decode_error_value("0d", FL_MESSAGE_CODEC_ERROR,
1044 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
1045 }

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 1052 of file fl_standard_message_codec_test.cc.

1052 {
1053 decode_error_value("0d0707", FL_MESSAGE_CODEC_ERROR,
1054 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
1055 }

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 1057 of file fl_standard_message_codec_test.cc.

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

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 936 of file fl_standard_message_codec_test.cc.

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

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 76 of file fl_standard_message_codec_test.cc.

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

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 362 of file fl_standard_message_codec_test.cc.

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

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 368 of file fl_standard_message_codec_test.cc.

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

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 379 of file fl_standard_message_codec_test.cc.

379 {
380 decode_error_value("0705", FL_MESSAGE_CODEC_ERROR,
381 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
382 }

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 374 of file fl_standard_message_codec_test.cc.

374 {
375 decode_error_value("07", FL_MESSAGE_CODEC_ERROR,
376 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
377 }

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 384 of file fl_standard_message_codec_test.cc.

384 {
385 decode_error_value("070568", FL_MESSAGE_CODEC_ERROR,
386 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
387 }

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 389 of file fl_standard_message_codec_test.cc.

389 {
390 decode_error_value("070568656c6c", FL_MESSAGE_CODEC_ERROR,
391 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
392 }

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 413 of file fl_standard_message_codec_test.cc.

413 {
414 g_autoptr(FlValue) value = decode_message("08050001020304");
415 ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_UINT8_LIST);
416 EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(5));
417 const uint8_t* data = fl_value_get_uint8_list(value);
418 EXPECT_EQ(data[0], 0);
419 EXPECT_EQ(data[1], 1);
420 EXPECT_EQ(data[2], 2);
421 EXPECT_EQ(data[3], 3);
422 EXPECT_EQ(data[4], 4);
423 }

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 407 of file fl_standard_message_codec_test.cc.

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

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 430 of file fl_standard_message_codec_test.cc.

430 {
431 decode_error_value("0805", FL_MESSAGE_CODEC_ERROR,
432 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
433 }

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 425 of file fl_standard_message_codec_test.cc.

425 {
426 decode_error_value("08", FL_MESSAGE_CODEC_ERROR,
427 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
428 }

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 435 of file fl_standard_message_codec_test.cc.

435 {
436 decode_error_value("080500", FL_MESSAGE_CODEC_ERROR,
437 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
438 }

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 440 of file fl_standard_message_codec_test.cc.

440 {
441 decode_error_value("080500010203", FL_MESSAGE_CODEC_ERROR,
442 FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA);
443 }

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 1088 of file fl_standard_message_codec_test.cc.

1088 {
1089 decode_error_value("0f", FL_MESSAGE_CODEC_ERROR,
1090 FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE);
1091 }

References decode_error_value(), FL_MESSAGE_CODEC_ERROR, and FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE.

## ◆ TEST() [81/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeBoolFalse |
| ) |  |

Definition at line 94 of file fl_standard_message_codec_test.cc.

94 {
95 g_autofree gchar* hex_string = encode_bool(FALSE);
96 EXPECT_STREQ(hex_string, "02");
97 }

References encode_bool().

## ◆ TEST() [82/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeBoolTrue |
| ) |  |

Definition at line 99 of file fl_standard_message_codec_test.cc.

99 {
100 g_autofree gchar* hex_string = encode_bool(TRUE);
101 EXPECT_STREQ(hex_string, "01");
102 }

References encode_bool(), and TRUE.

## ◆ TEST() [83/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeCustomType |
| ) |  |

Definition at line 1245 of file fl_standard_message_codec_test.cc.

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

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 1254 of file fl_standard_message_codec_test.cc.

1254 {
1255 g_autoptr(FlValue) value = fl_value_new_list();
1256 fl_value_append_take(value, fl_value_new_custom(128, "hello", nullptr));
1257 fl_value_append_take(value, fl_value_new_custom(129, nullptr, nullptr));
1258 g_autoptr(FlTestStandardMessageCodec) codec =
1259 fl_test_standard_message_codec_new();
1260 g_autofree gchar* hex_string =
1261 encode_message_with_codec(value, FL_MESSAGE_CODEC(codec));
1262 EXPECT_STREQ(hex_string, "0c02800568656c6c6f81");
1263 }

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 1265 of file fl_standard_message_codec_test.cc.

1265 {
1266 g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
1267
1268 g_autoptr(FlValue) input = fl_value_new_list();
1269 fl_value_append_take(input, fl_value_new_null());
1270 fl_value_append_take(input, fl_value_new_bool(TRUE));
1271 fl_value_append_take(input, fl_value_new_int(42));
1272 fl_value_append_take(input, fl_value_new_float(M_PI));
1273 fl_value_append_take(input, fl_value_new_string("hello"));
1274 fl_value_append_take(input, fl_value_new_list());
1275 fl_value_append_take(input, fl_value_new_map());
1276
1277 g_autoptr(GError) error = nullptr;
1278 g_autoptr(GBytes) message =
1279 fl_message_codec_encode_message(FL_MESSAGE_CODEC(codec), input, &error);
1280 EXPECT_NE(message, nullptr);
1281 EXPECT_EQ(error, nullptr);
1282
1283 g_autoptr(FlValue) output =
1284 fl_message_codec_decode_message(FL_MESSAGE_CODEC(codec), message, &error);
1285 EXPECT_EQ(error, nullptr);
1286 EXPECT_NE(output, nullptr);
1287
1288 ASSERT_TRUE(fl_value_equal(input, output));
1289 }

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 784 of file fl_standard_message_codec_test.cc.

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

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 1065 of file fl_standard_message_codec_test.cc.

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

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 561 of file fl_standard_message_codec_test.cc.

561 {
562 float data[] = {0.0f, -0.5f, 0.25f, -0.125f, 0.00625f};
563 g_autoptr(FlValue) value = fl_value_new_float32_list(data, 5);
564 g_autofree gchar* hex_string = encode_message(value);
565 EXPECT_STREQ(hex_string, "0e05000000000000000000bf0000803e000000becdcccc3b");
566 }

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

## ◆ TEST() [89/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloat32ListEmpty |
| ) |  |

Definition at line 555 of file fl_standard_message_codec_test.cc.

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

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

## ◆ TEST() [90/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatFraction |
| ) |  |

Definition at line 252 of file fl_standard_message_codec_test.cc.

252 {
253 g_autofree gchar* hex_string = encode_float(M_PI);
254 EXPECT_STREQ(hex_string, "0600000000000000182d4454fb210940");
255 }

References encode_float().

## ◆ TEST() [91/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatHalf |
| ) |  |

Definition at line 247 of file fl_standard_message_codec_test.cc.

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

References encode_float().

## ◆ TEST() [92/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatInfinity |
| ) |  |

Definition at line 267 of file fl_standard_message_codec_test.cc.

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

References encode_float().

## ◆ TEST() [93/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatList |
| ) |  |

Definition at line 613 of file fl_standard_message_codec_test.cc.

613 {
614 double data[] = {0, -0.5, 0.25, -0.125, 0.00625};
615 g_autoptr(FlValue) value = fl_value_new_float_list(data, 5);
616 g_autofree gchar* hex_string = encode_message(value);
617 EXPECT_STREQ(
618 hex_string,
619 "0b050000000000000000000000000000000000000000e0bf000000000000d03f00000000"
620 "0000c0bf9a9999999999793f");
621 }

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

## ◆ TEST() [94/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatListEmpty |
| ) |  |

Definition at line 607 of file fl_standard_message_codec_test.cc.

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

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

## ◆ TEST() [95/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatMinusOne |
| ) |  |

Definition at line 242 of file fl_standard_message_codec_test.cc.

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

References encode_float().

## ◆ TEST() [96/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatMinusZero |
| ) |  |

Definition at line 257 of file fl_standard_message_codec_test.cc.

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

References encode_float().

## ◆ TEST() [97/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatNaN |
| ) |  |

Definition at line 262 of file fl_standard_message_codec_test.cc.

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

References encode_float().

## ◆ TEST() [98/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatOne |
| ) |  |

Definition at line 237 of file fl_standard_message_codec_test.cc.

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

References encode_float().

## ◆ TEST() [99/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeFloatZero |
| ) |  |

Definition at line 232 of file fl_standard_message_codec_test.cc.

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

References encode_float().

## ◆ TEST() [100/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt32 |
| ) |  |

Definition at line 119 of file fl_standard_message_codec_test.cc.

119 {
120 g_autofree gchar* hex_string = encode_int(0x01234567);
121 EXPECT_STREQ(hex_string, "0367452301");
122 }

References encode_int().

## ◆ TEST() [101/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt32List |
| ) |  |

Definition at line 451 of file fl_standard_message_codec_test.cc.

451 {
452 int32_t data[] = {0, -1, 2, -3, 4};
453 g_autoptr(FlValue) value = fl_value_new_int32_list(data, 5);
454 g_autofree gchar* hex_string = encode_message(value);
455 EXPECT_STREQ(hex_string, "0905000000000000ffffffff02000000fdffffff04000000");
456 }

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

## ◆ TEST() [102/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt32ListEmpty |
| ) |  |

Definition at line 445 of file fl_standard_message_codec_test.cc.

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

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

## ◆ TEST() [103/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt32Max |
| ) |  |

Definition at line 129 of file fl_standard_message_codec_test.cc.

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

References encode_int().

## ◆ TEST() [104/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt32Min |
| ) |  |

Definition at line 124 of file fl_standard_message_codec_test.cc.

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

References encode_int().

## ◆ TEST() [105/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt64 |
| ) |  |

Definition at line 134 of file fl_standard_message_codec_test.cc.

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

References encode_int().

## ◆ TEST() [106/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt64List |
| ) |  |

Definition at line 503 of file fl_standard_message_codec_test.cc.

503 {
504 int64_t data[] = {0, -1, 2, -3, 4};
505 g_autoptr(FlValue) value = fl_value_new_int64_list(data, 5);
506 g_autofree gchar* hex_string = encode_message(value);
507 EXPECT_STREQ(
508 hex_string,
509 "0a050000000000000000000000000000ffffffffffffffff0200000000000000fdffffff"
510 "ffffffff0400000000000000");
511 }

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

## ◆ TEST() [107/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt64ListEmpty |
| ) |  |

Definition at line 497 of file fl_standard_message_codec_test.cc.

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

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

## ◆ TEST() [108/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt64Max |
| ) |  |

Definition at line 144 of file fl_standard_message_codec_test.cc.

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

References encode_int().

## ◆ TEST() [109/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeInt64Min |
| ) |  |

Definition at line 139 of file fl_standard_message_codec_test.cc.

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

References encode_int().

## ◆ TEST() [110/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeIntOne |
| ) |  |

Definition at line 114 of file fl_standard_message_codec_test.cc.

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

References encode_int().

## ◆ TEST() [111/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeIntZero |
| ) |  |

Definition at line 109 of file fl_standard_message_codec_test.cc.

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

References encode_int().

## ◆ TEST() [112/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeListEmpty |
| ) |  |

Definition at line 665 of file fl_standard_message_codec_test.cc.

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

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

## ◆ TEST() [113/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeListNested |
| ) |  |

Definition at line 686 of file fl_standard_message_codec_test.cc.

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

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 671 of file fl_standard_message_codec_test.cc.

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

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 806 of file fl_standard_message_codec_test.cc.

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

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

## ◆ TEST() [116/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeMapKeyTypes |
| ) |  |

Definition at line 812 of file fl_standard_message_codec_test.cc.

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

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 850 of file fl_standard_message_codec_test.cc.

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

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 831 of file fl_standard_message_codec_test.cc.

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

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 70 of file fl_standard_message_codec_test.cc.

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

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

## ◆ TEST() [120/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeNullptr |
| ) |  |

Definition at line 65 of file fl_standard_message_codec_test.cc.

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

References encode_message().

## ◆ TEST() [121/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeStringEmpty |
| ) |  |

Definition at line 340 of file fl_standard_message_codec_test.cc.

340 {
341 g_autofree gchar* hex_string = encode_string("");
342 EXPECT_STREQ(hex_string, "0700");
343 }

References encode_string().

## ◆ TEST() [122/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeStringEmptySized |
| ) |  |

Definition at line 350 of file fl_standard_message_codec_test.cc.

350 {
351 g_autoptr(FlValue) value = fl_value_new_string_sized(nullptr, 0);
352 g_autofree gchar* hex_string = encode_message(value);
353 EXPECT_STREQ(hex_string, "0700");
354 }

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

## ◆ TEST() [123/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeStringHello |
| ) |  |

Definition at line 345 of file fl_standard_message_codec_test.cc.

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

References encode_string().

## ◆ TEST() [124/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeStringHelloSized |
| ) |  |

Definition at line 356 of file fl_standard_message_codec_test.cc.

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

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

## ◆ TEST() [125/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeUint8List |
| ) |  |

Definition at line 400 of file fl_standard_message_codec_test.cc.

400 {
401 uint8_t data[] = {0, 1, 2, 3, 4};
402 g_autoptr(FlValue) value = fl_value_new_uint8_list(data, 5);
403 g_autofree gchar* hex_string = encode_message(value);
404 EXPECT_STREQ(hex_string, "08050001020304");
405 }

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

## ◆ TEST() [126/126]

TEST | ( | FlStandardMessageCodecTest | ,
|  | EncodeUint8ListEmpty |
| ) |  |

Definition at line 394 of file fl_standard_message_codec_test.cc.

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

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 1122 of file fl_standard_message_codec_test.cc.

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

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 1108 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 1110 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 1113 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_loop_body(), and flutter::ByteBufferStreamWriter::WriteBytes().

## ◆ TRUE

return TRUE

Definition at line 1119 of file fl_standard_message_codec_test.cc.

Referenced by TEST(), and write_custom_value2().

## ◆ type

uint8_t type = 128

Definition at line 1115 of file fl_standard_message_codec_test.cc.

Referenced by fl_key_channel_responder_handle_event(), fl_key_event_hash(), fl_key_event_new_from_gdk_event(), 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_loop_body(), synthesize_simple_event(), system_exit_application(), system_sound_play(), TEST(), and write_custom_value2().

## ◆ value

GByteArray FlValue* value

Definition at line 1109 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().

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:1131
fl_value_get_int32_list
const G_MODULE_EXPORT int32_t * fl_value_get_int32_list(FlValue *self)
Definition: fl_value.cc:696
FL_VALUE_TYPE_UINT8_LIST
@ FL_VALUE_TYPE_UINT8_LIST
Definition: fl_value.h:70
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
FL_VALUE_TYPE_MAP
@ FL_VALUE_TYPE_MAP
Definition: fl_value.h:75
fl_standard_message_codec_new
G_MODULE_EXPORT FlStandardMessageCodec * fl_standard_message_codec_new()
Definition: fl_standard_message_codec.cc:637
fl_test_standard_message_codec_new
static FlTestStandardMessageCodec * fl_test_standard_message_codec_new()
Definition: fl_standard_message_codec_test.cc:1212
type
uint8_t type
Definition: fl_standard_message_codec_test.cc:1115
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
fl_value_new_list
G_MODULE_EXPORT FlValue * fl_value_new_list()
Definition: fl_value.cc:349
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
i
int i
Definition: fl_socket_accessible.cc:18
fl_value_get_float_list
const G_MODULE_EXPORT double * fl_value_get_float_list(FlValue *self)
Definition: fl_value.cc:717
fl_value_new_bool
G_MODULE_EXPORT FlValue * fl_value_new_bool(bool value)
Definition: fl_value.cc:255
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42
encode_string
static gchar * encode_string(const gchar *value)
Definition: fl_standard_message_codec_test.cc:335
fl_value_set_take
G_MODULE_EXPORT void fl_value_set_take(FlValue *self, FlValue *key, FlValue *value)
Definition: fl_value.cc:618
fl_value_new_custom
G_MODULE_EXPORT FlValue * fl_value_new_custom(int type, gconstpointer value, GDestroyNotify destroy_notify)
Definition: fl_value.cc:374
fl_value_new_null
G_MODULE_EXPORT FlValue * fl_value_new_null()
Definition: fl_value.cc:251
FL_VALUE_TYPE_LIST
@ FL_VALUE_TYPE_LIST
Definition: fl_value.h:74
encode_int
static gchar * encode_int(int64_t value)
Definition: fl_standard_message_codec_test.cc:104
read_custom_value1
static FlValue * read_custom_value1(FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec_test.cc:1149
fl_value_get_bool
G_MODULE_EXPORT bool fl_value_get_bool(FlValue *self)
Definition: fl_value.cc:661
fl_value_get_uint8_list
const G_MODULE_EXPORT uint8_t * fl_value_get_uint8_list(FlValue *self)
Definition: fl_value.cc:689
fl_value_new_int
G_MODULE_EXPORT FlValue * fl_value_new_int(int64_t value)
Definition: fl_value.cc:262
fl_value_get_string
const G_MODULE_EXPORT gchar * fl_value_get_string(FlValue *self)
Definition: fl_value.cc:682
fl_value_get_float32_list
const G_MODULE_EXPORT float * fl_value_get_float32_list(FlValue *self)
Definition: fl_value.cc:710
FL_VALUE_TYPE_NULL
@ FL_VALUE_TYPE_NULL
Definition: fl_value.h:65
buffer
GByteArray * buffer
Definition: fl_standard_message_codec_test.cc:1108
fl_value_get_int
G_MODULE_EXPORT int64_t fl_value_get_int(FlValue *self)
Definition: fl_value.cc:668
fl_value_ref
G_MODULE_EXPORT FlValue * fl_value_ref(FlValue *self)
Definition: fl_value.cc:394
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_VALUE_TYPE_CUSTOM
@ FL_VALUE_TYPE_CUSTOM
Definition: fl_value.h:77
g_byte_array_append
g_byte_array_append(buffer, &type, sizeof(uint8_t))
fl_value_new_map
G_MODULE_EXPORT FlValue * fl_value_new_map()
Definition: fl_value.cc:366
fl_value_get_type
G_MODULE_EXPORT FlValueType fl_value_get_type(FlValue *self)
Definition: fl_value.cc:466
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_TYPE_FLOAT32_LIST
@ FL_VALUE_TYPE_FLOAT32_LIST
Definition: fl_value.h:76
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:1181
FL_VALUE_TYPE_STRING
@ FL_VALUE_TYPE_STRING
Definition: fl_value.h:69
read_custom_value2
static FlValue * read_custom_value2(FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec_test.cc:1174
fl_value_get_custom_value
G_MODULE_EXPORT gconstpointer fl_value_get_custom_value(FlValue *self)
Definition: fl_value.cc:830
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
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
fl_value_get_float
G_MODULE_EXPORT double fl_value_get_float(FlValue *self)
Definition: fl_value.cc:675
fl_value_append_take
G_MODULE_EXPORT void fl_value_append_take(FlValue *self, FlValue *value)
Definition: fl_value.cc:600
fl_value_get_length
G_MODULE_EXPORT size_t fl_value_get_length(FlValue *self)
Definition: fl_value.cc:724
FL_VALUE_TYPE_INT64_LIST
@ FL_VALUE_TYPE_INT64_LIST
Definition: fl_value.h:72
fl_value_equal
G_MODULE_EXPORT bool fl_value_equal(FlValue *a, FlValue *b)
Definition: fl_value.cc:471
fl_value_set_string
G_MODULE_EXPORT void fl_value_set_string(FlValue *self, const gchar *key, FlValue *value)
Definition: fl_value.cc:639
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
FL_VALUE_TYPE_INT
@ FL_VALUE_TYPE_INT
Definition: fl_value.h:67
encode_message
static gchar * encode_message(FlValue *value)
Definition: fl_standard_message_codec_test.cc:26
value
GByteArray FlValue * value
Definition: fl_standard_message_codec_test.cc:1109
TRUE
return TRUE
Definition: fl_standard_message_codec_test.cc:1119
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
encode_bool
static gchar * encode_bool(gboolean value)
Definition: fl_standard_message_codec_test.cc:89
FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA
@ FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA
Definition: fl_message_codec.h:35
write_custom_value2
static gboolean write_custom_value2(FlStandardMessageCodec *codec, GByteArray *buffer, FlValue *value, GError **error)
Definition: fl_standard_message_codec_test.cc:1122
fl_value_get_custom_type
G_MODULE_EXPORT int fl_value_get_custom_type(FlValue *self)
Definition: fl_value.cc:822
FL_VALUE_TYPE_FLOAT_LIST
@ FL_VALUE_TYPE_FLOAT_LIST
Definition: fl_value.h:73
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
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
fl_value_append
G_MODULE_EXPORT void fl_value_append(FlValue *self, FlValue *value)
Definition: fl_value.cc:592
FL_VALUE_TYPE_FLOAT
@ FL_VALUE_TYPE_FLOAT
Definition: fl_value.h:68
FL_VALUE_TYPE_INT32_LIST
@ FL_VALUE_TYPE_INT32_LIST
Definition: fl_value.h:71
FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE
@ FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE
Definition: fl_message_codec.h:37
fl_value_new_float
G_MODULE_EXPORT FlValue * fl_value_new_float(double value)
Definition: fl_value.cc:269
fl_value_get_map_key
G_MODULE_EXPORT FlValue * fl_value_get_map_key(FlValue *self, size_t index)
Definition: fl_value.cc:784
error
GByteArray FlValue GError ** error
Definition: fl_standard_message_codec_test.cc:1110
fl_value_get_int64_list
const G_MODULE_EXPORT int64_t * fl_value_get_int64_list(FlValue *self)
Definition: fl_value.cc:703
decode_error_value
static void decode_error_value(const char *hex_string, GQuark domain, gint code)
Definition: fl_standard_message_codec_test.cc:53
FL_VALUE_TYPE_BOOL
@ FL_VALUE_TYPE_BOOL
Definition: fl_value.h:66
decode_message_with_codec
static FlValue * decode_message_with_codec(const char *hex_string, FlMessageCodec *codec)
Definition: fl_standard_message_codec_test.cc:33
decode_message
static FlValue * decode_message(const char *hex_string)
Definition: fl_standard_message_codec_test.cc:46
encode_float
static gchar * encode_float(double value)
Definition: fl_standard_message_codec_test.cc:227
length
size_t length
Definition: fl_standard_message_codec_test.cc:1113
fl_value_get_map_value
G_MODULE_EXPORT FlValue * fl_value_get_map_value(FlValue *self, size_t index)
Definition: fl_value.cc:792
encode_message_with_codec
static gchar * encode_message_with_codec(FlValue *value, FlMessageCodec *codec)
Definition: fl_standard_message_codec_test.cc:14
fl_value_new_string
G_MODULE_EXPORT FlValue * fl_value_new_string(const gchar *value)
Definition: fl_value.cc:276
FL_MESSAGE_CODEC_ERROR
#define FL_MESSAGE_CODEC_ERROR
Definition: fl_message_codec.h:30