Add FlJsonMessageCodec (#18221)
diff --git a/ci/licenses_golden/licenses_flutter b/ci/licenses_golden/licenses_flutter
index 8ce5b14..daf9e19 100755
--- a/ci/licenses_golden/licenses_flutter
+++ b/ci/licenses_golden/licenses_flutter
@@ -1194,6 +1194,8 @@
FILE: ../../../flutter/shell/platform/linux/fl_dart_project_test.cc
FILE: ../../../flutter/shell/platform/linux/fl_engine.cc
FILE: ../../../flutter/shell/platform/linux/fl_engine_private.h
+FILE: ../../../flutter/shell/platform/linux/fl_json_message_codec.cc
+FILE: ../../../flutter/shell/platform/linux/fl_json_message_codec_test.cc
FILE: ../../../flutter/shell/platform/linux/fl_message_codec.cc
FILE: ../../../flutter/shell/platform/linux/fl_message_codec_test.cc
FILE: ../../../flutter/shell/platform/linux/fl_renderer.cc
@@ -1213,6 +1215,7 @@
FILE: ../../../flutter/shell/platform/linux/public/flutter_linux/fl_binary_messenger.h
FILE: ../../../flutter/shell/platform/linux/public/flutter_linux/fl_dart_project.h
FILE: ../../../flutter/shell/platform/linux/public/flutter_linux/fl_engine.h
+FILE: ../../../flutter/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h
FILE: ../../../flutter/shell/platform/linux/public/flutter_linux/fl_message_codec.h
FILE: ../../../flutter/shell/platform/linux/public/flutter_linux/fl_standard_message_codec.h
FILE: ../../../flutter/shell/platform/linux/public/flutter_linux/fl_string_codec.h
diff --git a/shell/platform/linux/BUILD.gn b/shell/platform/linux/BUILD.gn
index 5b3f865..aa2c35a 100644
--- a/shell/platform/linux/BUILD.gn
+++ b/shell/platform/linux/BUILD.gn
@@ -49,6 +49,7 @@
"public/flutter_linux/fl_binary_messenger.h",
"public/flutter_linux/fl_dart_project.h",
"public/flutter_linux/fl_engine.h",
+ "public/flutter_linux/fl_json_message_codec.h",
"public/flutter_linux/fl_message_codec.h",
"public/flutter_linux/fl_standard_message_codec.h",
"public/flutter_linux/fl_string_codec.h",
@@ -70,6 +71,7 @@
"fl_binary_messenger.cc",
"fl_dart_project.cc",
"fl_engine.cc",
+ "fl_json_message_codec.cc",
"fl_message_codec.cc",
"fl_renderer.cc",
"fl_renderer_x11.cc",
@@ -90,6 +92,7 @@
deps = [
"//flutter/shell/platform/embedder:embedder_with_symbol_prefix",
+ "//third_party/rapidjson",
]
}
@@ -103,6 +106,7 @@
sources = [
"fl_binary_codec_test.cc",
"fl_dart_project_test.cc",
+ "fl_json_message_codec_test.cc",
"fl_message_codec_test.cc",
"fl_standard_message_codec_test.cc",
"fl_string_codec_test.cc",
diff --git a/shell/platform/linux/fl_json_message_codec.cc b/shell/platform/linux/fl_json_message_codec.cc
new file mode 100644
index 0000000..ded2c20
--- /dev/null
+++ b/shell/platform/linux/fl_json_message_codec.cc
@@ -0,0 +1,320 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h"
+
+#include "rapidjson/reader.h"
+#include "rapidjson/writer.h"
+
+#include <gmodule.h>
+
+G_DEFINE_QUARK(fl_json_message_codec_error_quark, fl_json_message_codec_error)
+
+struct _FlJsonMessageCodec {
+ FlMessageCodec parent_instance;
+};
+
+G_DEFINE_TYPE(FlJsonMessageCodec,
+ fl_json_message_codec,
+ fl_message_codec_get_type())
+
+// Recursively writes #FlValue objects using rapidjson
+static gboolean write_value(rapidjson::Writer<rapidjson::StringBuffer>& writer,
+ FlValue* value,
+ GError** error) {
+ if (value == nullptr) {
+ writer.Null();
+ return TRUE;
+ }
+
+ switch (fl_value_get_type(value)) {
+ case FL_VALUE_TYPE_NULL:
+ writer.Null();
+ break;
+ case FL_VALUE_TYPE_BOOL:
+ writer.Bool(fl_value_get_bool(value));
+ break;
+ case FL_VALUE_TYPE_INT:
+ writer.Int64(fl_value_get_int(value));
+ break;
+ case FL_VALUE_TYPE_FLOAT:
+ writer.Double(fl_value_get_float(value));
+ break;
+ case FL_VALUE_TYPE_STRING:
+ writer.String(fl_value_get_string(value));
+ break;
+ case FL_VALUE_TYPE_UINT8_LIST: {
+ writer.StartArray();
+ const uint8_t* data = fl_value_get_uint8_list(value);
+ for (size_t i = 0; i < fl_value_get_length(value); i++)
+ writer.Int(data[i]);
+ writer.EndArray();
+ break;
+ }
+ case FL_VALUE_TYPE_INT32_LIST: {
+ writer.StartArray();
+ const int32_t* data = fl_value_get_int32_list(value);
+ for (size_t i = 0; i < fl_value_get_length(value); i++)
+ writer.Int(data[i]);
+ writer.EndArray();
+ break;
+ }
+ case FL_VALUE_TYPE_INT64_LIST: {
+ writer.StartArray();
+ const int64_t* data = fl_value_get_int64_list(value);
+ for (size_t i = 0; i < fl_value_get_length(value); i++)
+ writer.Int64(data[i]);
+ writer.EndArray();
+ break;
+ }
+ case FL_VALUE_TYPE_FLOAT_LIST: {
+ writer.StartArray();
+ const double* data = fl_value_get_float_list(value);
+ for (size_t i = 0; i < fl_value_get_length(value); i++)
+ writer.Double(data[i]);
+ writer.EndArray();
+ break;
+ }
+ case FL_VALUE_TYPE_LIST: {
+ writer.StartArray();
+ for (size_t i = 0; i < fl_value_get_length(value); i++)
+ if (!write_value(writer, fl_value_get_list_value(value, i), error))
+ return FALSE;
+ writer.EndArray();
+ break;
+ }
+ case FL_VALUE_TYPE_MAP: {
+ writer.StartObject();
+ for (size_t i = 0; i < fl_value_get_length(value); i++) {
+ FlValue* key = fl_value_get_map_key(value, i);
+ if (fl_value_get_type(key) != FL_VALUE_TYPE_STRING) {
+ g_set_error(error, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE,
+ "Invalid object key type");
+ return FALSE;
+ }
+ writer.Key(fl_value_get_string(key));
+ if (!write_value(writer, fl_value_get_map_value(value, i), error))
+ return FALSE;
+ }
+ writer.EndObject();
+ break;
+ }
+ default:
+ g_set_error(error, FL_MESSAGE_CODEC_ERROR,
+ FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE,
+ "Unexpected FlValue type %d", fl_value_get_type(value));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+// Handler to parse JSON using rapidjson in SAX mode
+struct FlValueHandler {
+ GPtrArray* stack;
+ FlValue* key;
+ GError* error;
+
+ FlValueHandler() {
+ stack = g_ptr_array_new_with_free_func(
+ reinterpret_cast<GDestroyNotify>(fl_value_unref));
+ key = nullptr;
+ error = nullptr;
+ }
+
+ ~FlValueHandler() {
+ g_ptr_array_unref(stack);
+ if (key != nullptr)
+ fl_value_unref(key);
+ if (error != nullptr)
+ g_error_free(error);
+ }
+
+ // Gets the current head of the stack
+ FlValue* get_head() {
+ if (stack->len == 0)
+ return nullptr;
+ return static_cast<FlValue*>(g_ptr_array_index(stack, stack->len - 1));
+ }
+
+ // Pushes a value onto the stack
+ void push(FlValue* value) { g_ptr_array_add(stack, fl_value_ref(value)); }
+
+ // Pops the stack
+ void pop() { g_ptr_array_remove_index(stack, stack->len - 1); }
+
+ // Adds a new value to the stack
+ bool add(FlValue* value) {
+ g_autoptr(FlValue) owned_value = value;
+ FlValue* head = get_head();
+ if (head == nullptr)
+ push(owned_value);
+ else if (fl_value_get_type(head) == FL_VALUE_TYPE_LIST)
+ fl_value_append(head, owned_value);
+ else if (fl_value_get_type(head) == FL_VALUE_TYPE_MAP) {
+ fl_value_set_take(head, key, fl_value_ref(owned_value));
+ key = nullptr;
+ } else {
+ g_set_error(&error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
+ "Can't add value to non container");
+ return false;
+ }
+
+ if (fl_value_get_type(owned_value) == FL_VALUE_TYPE_LIST ||
+ fl_value_get_type(owned_value) == FL_VALUE_TYPE_MAP)
+ push(value);
+
+ return true;
+ }
+
+ // The following implements the rapidjson SAX API
+
+ bool Null() { return add(fl_value_new_null()); }
+
+ bool Bool(bool b) { return add(fl_value_new_bool(b)); }
+
+ bool Int(int i) { return add(fl_value_new_int(i)); }
+
+ bool Uint(unsigned i) { return add(fl_value_new_int(i)); }
+
+ bool Int64(int64_t i) { return add(fl_value_new_int(i)); }
+
+ bool Uint64(uint64_t i) {
+ // For some reason (bug in rapidjson?) this is not returned in Int64
+ if (i == G_MAXINT64)
+ return add(fl_value_new_int(i));
+ else
+ return add(fl_value_new_float(i));
+ }
+
+ bool Double(double d) { return add(fl_value_new_float(d)); }
+
+ bool RawNumber(const char* str, rapidjson::SizeType length, bool copy) {
+ g_set_error(&error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
+ "RawNumber not supported");
+ return false;
+ }
+
+ bool String(const char* str, rapidjson::SizeType length, bool copy) {
+ FlValue* v = fl_value_new_string_sized(str, length);
+ return add(v);
+ }
+
+ bool StartObject() { return add(fl_value_new_map()); }
+
+ bool Key(const char* str, rapidjson::SizeType length, bool copy) {
+ if (key != nullptr)
+ fl_value_unref(key);
+ key = fl_value_new_string_sized(str, length);
+ return true;
+ }
+
+ bool EndObject(rapidjson::SizeType memberCount) {
+ pop();
+ return true;
+ }
+
+ bool StartArray() { return add(fl_value_new_list()); }
+
+ bool EndArray(rapidjson::SizeType elementCount) {
+ pop();
+ return true;
+ }
+};
+
+// Implements FlMessageCodec:encode_message
+static GBytes* fl_json_message_codec_encode_message(FlMessageCodec* codec,
+ FlValue* message,
+ GError** error) {
+ rapidjson::StringBuffer buffer;
+ rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+
+ if (!write_value(writer, message, error))
+ return nullptr;
+
+ const gchar* text = buffer.GetString();
+ return g_bytes_new(text, strlen(text));
+}
+
+// Implements FlMessageCodec:decode_message
+static FlValue* fl_json_message_codec_decode_message(FlMessageCodec* codec,
+ GBytes* message,
+ GError** error) {
+ gsize data_length;
+ const gchar* data =
+ static_cast<const char*>(g_bytes_get_data(message, &data_length));
+ if (!g_utf8_validate(data, data_length, nullptr)) {
+ g_set_error(error, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_UTF8,
+ "Message is not valid UTF8");
+ return nullptr;
+ }
+
+ FlValueHandler handler;
+ rapidjson::Reader reader;
+ rapidjson::MemoryStream ss(data, data_length);
+ if (!reader.Parse(ss, handler)) {
+ if (handler.error != nullptr) {
+ g_propagate_error(error, handler.error);
+ handler.error = nullptr;
+ } else
+ g_set_error(error, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON,
+ "Message is not valid JSON");
+ return nullptr;
+ }
+
+ FlValue* value = handler.get_head();
+ if (value == nullptr) {
+ g_set_error(error, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON,
+ "Message is not valid JSON");
+ return nullptr;
+ }
+
+ return fl_value_ref(value);
+}
+
+static void fl_json_message_codec_class_init(FlJsonMessageCodecClass* klass) {
+ FL_MESSAGE_CODEC_CLASS(klass)->encode_message =
+ fl_json_message_codec_encode_message;
+ FL_MESSAGE_CODEC_CLASS(klass)->decode_message =
+ fl_json_message_codec_decode_message;
+}
+
+static void fl_json_message_codec_init(FlJsonMessageCodec* self) {}
+
+G_MODULE_EXPORT FlJsonMessageCodec* fl_json_message_codec_new() {
+ return static_cast<FlJsonMessageCodec*>(
+ g_object_new(fl_json_message_codec_get_type(), nullptr));
+}
+
+G_MODULE_EXPORT gchar* fl_json_message_codec_encode(FlJsonMessageCodec* codec,
+ FlValue* value,
+ GError** error) {
+ g_return_val_if_fail(FL_IS_JSON_CODEC(codec), nullptr);
+
+ rapidjson::StringBuffer buffer;
+ rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+
+ if (!write_value(writer, value, error))
+ return nullptr;
+
+ return g_strdup(buffer.GetString());
+}
+
+G_MODULE_EXPORT FlValue* fl_json_message_codec_decode(FlJsonMessageCodec* codec,
+ const gchar* text,
+ GError** error) {
+ g_return_val_if_fail(FL_IS_JSON_CODEC(codec), nullptr);
+
+ g_autoptr(GBytes) data = g_bytes_new_static(text, strlen(text));
+ g_autoptr(FlValue) value = fl_json_message_codec_decode_message(
+ FL_MESSAGE_CODEC(codec), data, error);
+ if (value == nullptr)
+ return nullptr;
+
+ return fl_value_ref(value);
+}
diff --git a/shell/platform/linux/fl_json_message_codec_test.cc b/shell/platform/linux/fl_json_message_codec_test.cc
new file mode 100644
index 0000000..43a19d3
--- /dev/null
+++ b/shell/platform/linux/fl_json_message_codec_test.cc
@@ -0,0 +1,783 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h"
+#include "gtest/gtest.h"
+
+#include <math.h>
+
+// Encodes a message using FlJsonMessageCodec to a UTF-8 string.
+static gchar* encode_message(FlValue* value) {
+ g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
+ g_autoptr(GError) error = nullptr;
+ g_autofree gchar* result = fl_json_message_codec_encode(codec, value, &error);
+ EXPECT_EQ(error, nullptr);
+ return static_cast<gchar*>(g_steal_pointer(&result));
+}
+
+// Encodes a message using FlJsonMessageCodec to a UTF-8 string. Expect the
+// given error.
+static void encode_error_message(FlValue* value, GQuark domain, gint code) {
+ g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
+ g_autoptr(GError) error = nullptr;
+ g_autofree gchar* result = fl_json_message_codec_encode(codec, value, &error);
+ EXPECT_TRUE(g_error_matches(error, domain, code));
+ EXPECT_EQ(result, nullptr);
+}
+
+// Decodes a message using FlJsonMessageCodec from UTF-8 string.
+static FlValue* decode_message(const char* text) {
+ g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
+ g_autoptr(GError) error = nullptr;
+ g_autoptr(FlValue) value = fl_json_message_codec_decode(codec, text, &error);
+ EXPECT_EQ(error, nullptr);
+ EXPECT_NE(value, nullptr);
+ return fl_value_ref(value);
+}
+
+// Decodes a message using FlJsonMessageCodec from UTF-8 string. Expect the
+// given error.
+static void decode_error_message(const char* text, GQuark domain, gint code) {
+ g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
+ g_autoptr(GError) error = nullptr;
+ g_autoptr(FlValue) value = fl_json_message_codec_decode(codec, text, &error);
+ EXPECT_TRUE(g_error_matches(error, domain, code));
+ EXPECT_EQ(value, nullptr);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeNullptr) {
+ g_autofree gchar* text = encode_message(nullptr);
+ EXPECT_STREQ(text, "null");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeNull) {
+ g_autoptr(FlValue) value = fl_value_new_null();
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "null");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeNull) {
+ g_autoptr(FlValue) value = decode_message("null");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_NULL);
+}
+
+static gchar* encode_bool(gboolean value) {
+ g_autoptr(FlValue) v = fl_value_new_bool(value);
+ return encode_message(v);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeBoolFalse) {
+ g_autofree gchar* text = encode_bool(FALSE);
+ EXPECT_STREQ(text, "false");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeBoolTrue) {
+ g_autofree gchar* text = encode_bool(TRUE);
+ EXPECT_STREQ(text, "true");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeBoolFalse) {
+ g_autoptr(FlValue) value = decode_message("false");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_BOOL);
+ EXPECT_FALSE(fl_value_get_bool(value));
+}
+
+TEST(FlJsonMessageCodecTest, DecodeBoolTrue) {
+ g_autoptr(FlValue) value = decode_message("true");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_BOOL);
+ EXPECT_TRUE(fl_value_get_bool(value));
+}
+
+static gchar* encode_int(int64_t value) {
+ g_autoptr(FlValue) v = fl_value_new_int(value);
+ return encode_message(v);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeIntZero) {
+ g_autofree gchar* text = encode_int(0);
+ EXPECT_STREQ(text, "0");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeIntOne) {
+ g_autofree gchar* text = encode_int(1);
+ EXPECT_STREQ(text, "1");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeInt12345) {
+ g_autofree gchar* text = encode_int(12345);
+ EXPECT_STREQ(text, "12345");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeIntMin) {
+ g_autofree gchar* text = encode_int(G_MININT64);
+ EXPECT_STREQ(text, "-9223372036854775808");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeIntMax) {
+ g_autofree gchar* text = encode_int(G_MAXINT64);
+ EXPECT_STREQ(text, "9223372036854775807");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeIntZero) {
+ g_autoptr(FlValue) value = decode_message("0");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
+ EXPECT_EQ(fl_value_get_int(value), 0);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeIntOne) {
+ g_autoptr(FlValue) value = decode_message("1");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
+ EXPECT_EQ(fl_value_get_int(value), 1);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeInt12345) {
+ g_autoptr(FlValue) value = decode_message("12345");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
+ EXPECT_EQ(fl_value_get_int(value), 12345);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeIntMin) {
+ g_autoptr(FlValue) value = decode_message("-9223372036854775808");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
+ EXPECT_EQ(fl_value_get_int(value), G_MININT64);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeIntMax) {
+ g_autoptr(FlValue) value = decode_message("9223372036854775807");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_INT);
+ EXPECT_EQ(fl_value_get_int(value), G_MAXINT64);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeUintMax) {
+ // This is bigger than an signed 64 bit integer, so we expect it to be
+ // represented as a double
+ g_autoptr(FlValue) value = decode_message("18446744073709551615");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
+ EXPECT_EQ(fl_value_get_float(value), 1.8446744073709551615e+19);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeHugeNumber) {
+ // This is bigger than an unsigned 64 bit integer, so we expect it to be
+ // represented as a double
+ g_autoptr(FlValue) value = decode_message("184467440737095516150");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
+ EXPECT_EQ(fl_value_get_float(value), 1.84467440737095516150e+20);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeIntLeadingZero1) {
+ decode_error_message("00", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeIntLeadingZero2) {
+ decode_error_message("01", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeIntDoubleNegative) {
+ decode_error_message("--1", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeIntPositiveSign) {
+ decode_error_message("+1", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeIntHexChar) {
+ decode_error_message("0a", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+static gchar* encode_float(double value) {
+ g_autoptr(FlValue) v = fl_value_new_float(value);
+ return encode_message(v);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeFloatZero) {
+ g_autofree gchar* text = encode_float(0);
+ EXPECT_STREQ(text, "0.0");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeFloatOne) {
+ g_autofree gchar* text = encode_float(1);
+ EXPECT_STREQ(text, "1.0");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeFloatMinusOne) {
+ g_autofree gchar* text = encode_float(-1);
+ EXPECT_STREQ(text, "-1.0");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeFloatHalf) {
+ g_autofree gchar* text = encode_float(0.5);
+ EXPECT_STREQ(text, "0.5");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeFloatPi) {
+ g_autofree gchar* text = encode_float(M_PI);
+ EXPECT_STREQ(text, "3.141592653589793");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeFloatMinusZero) {
+ g_autofree gchar* text = encode_float(-0.0);
+ EXPECT_STREQ(text, "-0.0");
+}
+
+// NOTE(robert-ancell): JSON doesn't support encoding of NAN and INFINITY, but
+// rapidjson doesn't seem to either encode them or treat them as an error.
+
+TEST(FlJsonMessageCodecTest, DecodeFloatZero) {
+ g_autoptr(FlValue) value = decode_message("0.0");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
+ EXPECT_EQ(fl_value_get_float(value), 0.0);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeFloatOne) {
+ g_autoptr(FlValue) value = decode_message("1.0");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
+ EXPECT_EQ(fl_value_get_float(value), 1.0);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeFloatMinusOne) {
+ g_autoptr(FlValue) value = decode_message("-1.0");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
+ EXPECT_EQ(fl_value_get_float(value), -1.0);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeFloatHalf) {
+ g_autoptr(FlValue) value = decode_message("0.5");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
+ EXPECT_EQ(fl_value_get_float(value), 0.5);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeFloatPi) {
+ g_autoptr(FlValue) value = decode_message("3.1415926535897931");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
+ EXPECT_EQ(fl_value_get_float(value), M_PI);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeFloatMinusZero) {
+ g_autoptr(FlValue) value = decode_message("-0.0");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_FLOAT);
+ EXPECT_EQ(fl_value_get_float(value), -0.0);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeFloatMissingFraction) {
+ decode_error_message("0.", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeFloatInvalidFraction) {
+ decode_error_message("0.a", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+static gchar* encode_string(const gchar* value) {
+ g_autoptr(FlValue) v = fl_value_new_string(value);
+ return encode_message(v);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEmpty) {
+ g_autofree gchar* text = encode_string("");
+ EXPECT_STREQ(text, "\"\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringHello) {
+ g_autofree gchar* text = encode_string("hello");
+ EXPECT_STREQ(text, "\"hello\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEmptySized) {
+ g_autoptr(FlValue) value = fl_value_new_string_sized(nullptr, 0);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "\"\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringHelloSized) {
+ g_autoptr(FlValue) value = fl_value_new_string_sized("Hello World", 5);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "\"Hello\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEscapeQuote) {
+ g_autofree gchar* text = encode_string("\"");
+ EXPECT_STREQ(text, "\"\\\"\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEscapeBackslash) {
+ g_autofree gchar* text = encode_string("\\");
+ EXPECT_STREQ(text, "\"\\\\\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEscapeBackspace) {
+ g_autofree gchar* text = encode_string("\b");
+ EXPECT_STREQ(text, "\"\\b\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEscapeFormFeed) {
+ g_autofree gchar* text = encode_string("\f");
+ EXPECT_STREQ(text, "\"\\f\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEscapeNewline) {
+ g_autofree gchar* text = encode_string("\n");
+ EXPECT_STREQ(text, "\"\\n\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEscapeCarriageReturn) {
+ g_autofree gchar* text = encode_string("\r");
+ EXPECT_STREQ(text, "\"\\r\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEscapeTab) {
+ g_autofree gchar* text = encode_string("\t");
+ EXPECT_STREQ(text, "\"\\t\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEscapeUnicode) {
+ g_autofree gchar* text = encode_string("\u0001");
+ EXPECT_STREQ(text, "\"\\u0001\"");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeStringEmoji) {
+ g_autofree gchar* text = encode_string("😀");
+ EXPECT_STREQ(text, "\"😀\"");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEmpty) {
+ g_autoptr(FlValue) value = decode_message("\"\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringHello) {
+ g_autoptr(FlValue) value = decode_message("\"hello\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "hello");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeQuote) {
+ g_autoptr(FlValue) value = decode_message("\"\\\"\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "\"");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeBackslash) {
+ g_autoptr(FlValue) value = decode_message("\"\\\\\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "\\");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeSlash) {
+ g_autoptr(FlValue) value = decode_message("\"\\/\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "/");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeBackspace) {
+ g_autoptr(FlValue) value = decode_message("\"\\b\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "\b");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeFormFeed) {
+ g_autoptr(FlValue) value = decode_message("\"\\f\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "\f");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeNewline) {
+ g_autoptr(FlValue) value = decode_message("\"\\n\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "\n");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeCarriageReturn) {
+ g_autoptr(FlValue) value = decode_message("\"\\r\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "\r");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeTab) {
+ g_autoptr(FlValue) value = decode_message("\"\\t\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "\t");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeUnicode) {
+ g_autoptr(FlValue) value = decode_message("\"\\u0001\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "\u0001");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEmoji) {
+ g_autoptr(FlValue) value = decode_message("\"😀\"");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
+ EXPECT_STREQ(fl_value_get_string(value), "😀");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeInvalidUTF8) {
+ decode_error_message("\xff", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_UTF8);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringInvalidUTF8) {
+ decode_error_message("\"\xff\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_UTF8);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringBinary) {
+ decode_error_message("\"Hello\x01World\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringNewline) {
+ decode_error_message("\"Hello\nWorld\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringCarriageReturn) {
+ decode_error_message("\"Hello\rWorld\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringTab) {
+ decode_error_message("\"Hello\tWorld\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringUnterminatedEmpty) {
+ decode_error_message("\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringExtraQuote) {
+ decode_error_message("\"\"\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapedClosingQuote) {
+ decode_error_message("\"\\\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringUnknownEscape) {
+ decode_error_message("\"\\z\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringInvalidEscapeUnicode) {
+ decode_error_message("\"\\uxxxx\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeUnicodeNoData) {
+ decode_error_message("\"\\u\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeStringEscapeUnicodeShortData) {
+ decode_error_message("\"\\uxx\"", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeUint8ListEmpty) {
+ g_autoptr(FlValue) value = fl_value_new_uint8_list(nullptr, 0);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeUint8List) {
+ uint8_t data[] = {0, 1, 2, 3, 4};
+ g_autoptr(FlValue) value = fl_value_new_uint8_list(data, 5);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[0,1,2,3,4]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeInt32ListEmpty) {
+ g_autoptr(FlValue) value = fl_value_new_int32_list(nullptr, 0);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeInt32List) {
+ int32_t data[] = {0, -1, 2, -3, 4};
+ g_autoptr(FlValue) value = fl_value_new_int32_list(data, 5);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[0,-1,2,-3,4]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeInt64ListEmpty) {
+ g_autoptr(FlValue) value = fl_value_new_int64_list(nullptr, 0);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeInt64List) {
+ int64_t data[] = {0, -1, 2, -3, 4};
+ g_autoptr(FlValue) value = fl_value_new_int64_list(data, 5);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[0,-1,2,-3,4]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeFloatListEmpty) {
+ g_autoptr(FlValue) value = fl_value_new_float_list(nullptr, 0);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeFloatList) {
+ double data[] = {0, -0.5, 0.25, -0.125, 0.0625};
+ g_autoptr(FlValue) value = fl_value_new_float_list(data, 5);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[0.0,-0.5,0.25,-0.125,0.0625]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeListEmpty) {
+ g_autoptr(FlValue) value = fl_value_new_list();
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeListTypes) {
+ g_autoptr(FlValue) value = fl_value_new_list();
+ fl_value_append_take(value, fl_value_new_null());
+ fl_value_append_take(value, fl_value_new_bool(TRUE));
+ fl_value_append_take(value, fl_value_new_int(42));
+ fl_value_append_take(value, fl_value_new_float(-1.5));
+ fl_value_append_take(value, fl_value_new_string("hello"));
+ fl_value_append_take(value, fl_value_new_list());
+ fl_value_append_take(value, fl_value_new_map());
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[null,true,42,-1.5,\"hello\",[],{}]");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeListNested) {
+ g_autoptr(FlValue) even_numbers = fl_value_new_list();
+ g_autoptr(FlValue) odd_numbers = fl_value_new_list();
+ for (int i = 0; i < 10; i++) {
+ if (i % 2 == 0)
+ fl_value_append_take(even_numbers, fl_value_new_int(i));
+ else
+ fl_value_append_take(odd_numbers, fl_value_new_int(i));
+ }
+ g_autoptr(FlValue) value = fl_value_new_list();
+ fl_value_append(value, even_numbers);
+ fl_value_append(value, odd_numbers);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "[[0,2,4,6,8],[1,3,5,7,9]]");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeListEmpty) {
+ g_autoptr(FlValue) value = decode_message("[]");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_LIST);
+ EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(0));
+}
+
+TEST(FlJsonMessageCodecTest, DecodeListNoComma) {
+ decode_error_message("[0,1,2,3 4]", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeListUnterminatedEmpty) {
+ decode_error_message("[", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeListStartUnterminate) {
+ decode_error_message("]", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeListUnterminated) {
+ decode_error_message("[0,1,2,3,4", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeListDoubleTerminated) {
+ decode_error_message("[0,1,2,3,4]]", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapEmpty) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text, "{}");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapNullKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_null(), fl_value_new_string("null"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapBoolKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_bool(TRUE),
+ fl_value_new_string("bool"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapIntKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_int(42), fl_value_new_string("int"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapFloatKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_float(M_PI),
+ fl_value_new_string("float"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapUint8ListKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_uint8_list(nullptr, 0),
+ fl_value_new_string("uint8_list"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapInt32ListKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_int32_list(nullptr, 0),
+ fl_value_new_string("int32_list"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapInt64ListKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_int64_list(nullptr, 0),
+ fl_value_new_string("int64_list"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapFloatListKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_float_list(nullptr, 0),
+ fl_value_new_string("float_list"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapListKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_list(), fl_value_new_string("list"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapMapKey) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_map(), fl_value_new_string("map"));
+ encode_error_message(value, FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapValueTypes) {
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_take(value, fl_value_new_string("null"), fl_value_new_null());
+ fl_value_set_take(value, fl_value_new_string("bool"),
+ fl_value_new_bool(TRUE));
+ fl_value_set_take(value, fl_value_new_string("int"), fl_value_new_int(42));
+ fl_value_set_take(value, fl_value_new_string("float"),
+ fl_value_new_float(-1.5));
+ fl_value_set_take(value, fl_value_new_string("string"),
+ fl_value_new_string("hello"));
+ fl_value_set_take(value, fl_value_new_string("list"), fl_value_new_list());
+ fl_value_set_take(value, fl_value_new_string("map"), fl_value_new_map());
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text,
+ "{\"null\":null,\"bool\":true,\"int\":42,\"float\":-"
+ "1.5,\"string\":\"hello\",\"list\":[],\"map\":{}}");
+}
+
+TEST(FlJsonMessageCodecTest, EncodeMapNested) {
+ g_autoptr(FlValue) str_to_int = fl_value_new_map();
+ const char* numbers[] = {"zero", "one", "two", "three", nullptr};
+ for (int i = 0; numbers[i] != nullptr; i++) {
+ fl_value_set_take(str_to_int, fl_value_new_string(numbers[i]),
+ fl_value_new_int(i));
+ }
+ g_autoptr(FlValue) value = fl_value_new_map();
+ fl_value_set_string(value, "str-to-int", str_to_int);
+ g_autofree gchar* text = encode_message(value);
+ EXPECT_STREQ(text,
+ "{\"str-to-int\":{\"zero\":0,\"one\":1,\"two\":2,\"three\":3}}");
+}
+
+TEST(FlJsonMessageCodecTest, DecodeMapEmpty) {
+ g_autoptr(FlValue) value = decode_message("{}");
+ ASSERT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
+ EXPECT_EQ(fl_value_get_length(value), static_cast<size_t>(0));
+}
+
+TEST(FlJsonMessageCodecTest, DecodeMapUnterminatedEmpty) {
+ decode_error_message("{", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeMapStartUnterminate) {
+ decode_error_message("}", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeMapNoComma) {
+ decode_error_message("{\"zero\":0 \"one\":1}", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeMapNoColon) {
+ decode_error_message("{\"zero\" 0,\"one\":1}", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeMapUnterminated) {
+ decode_error_message("{\"zero\":0,\"one\":1", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeMapDoubleTerminated) {
+ decode_error_message("{\"zero\":0,\"one\":1}}", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, DecodeUnknownWord) {
+ decode_error_message("foo", FL_JSON_MESSAGE_CODEC_ERROR,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON);
+}
+
+TEST(FlJsonMessageCodecTest, EncodeDecode) {
+ g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
+
+ g_autoptr(FlValue) input = fl_value_new_list();
+ fl_value_append_take(input, fl_value_new_null());
+ fl_value_append_take(input, fl_value_new_bool(TRUE));
+ fl_value_append_take(input, fl_value_new_int(42));
+ fl_value_append_take(input, fl_value_new_float(M_PI));
+ fl_value_append_take(input, fl_value_new_string("hello"));
+ fl_value_append_take(input, fl_value_new_list());
+ fl_value_append_take(input, fl_value_new_map());
+
+ g_autoptr(GError) error = nullptr;
+ g_autofree gchar* message =
+ fl_json_message_codec_encode(codec, input, &error);
+ ASSERT_NE(message, nullptr);
+ EXPECT_EQ(error, nullptr);
+
+ g_autoptr(FlValue) output =
+ fl_json_message_codec_decode(codec, message, &error);
+ EXPECT_EQ(error, nullptr);
+ EXPECT_NE(output, nullptr);
+
+ EXPECT_TRUE(fl_value_equal(input, output));
+}
diff --git a/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h b/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h
new file mode 100644
index 0000000..5796ffe
--- /dev/null
+++ b/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h
@@ -0,0 +1,93 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_LINUX_FL_JSON_MESSAGE_CODEC_H_
+#define FLUTTER_SHELL_PLATFORM_LINUX_FL_JSON_MESSAGE_CODEC_H_
+
+#if !defined(__FLUTTER_LINUX_INSIDE__) && !defined(FLUTTER_LINUX_COMPILATION)
+#error "Only <flutter_linux/flutter_linux.h> can be included directly."
+#endif
+
+#include "fl_message_codec.h"
+
+G_BEGIN_DECLS
+
+/**
+ * FlJsonMessageCodecError:
+ * @FL_JSON_MESSAGE_CODEC_ERROR_INVALID_UTF8: Message is not valid UTF-8.
+ * @FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON: Message is not valid JSON.
+ * @FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE: Invalid object key type
+ *
+ * Errors for #FlJsonMessageCodec objects to set on failures.
+ */
+#define FL_JSON_MESSAGE_CODEC_ERROR fl_json_message_codec_error_quark()
+
+typedef enum {
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_UTF8,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON,
+ FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE,
+} FlJsonMessageCodecError;
+
+GQuark fl_json_message_codec_error_quark(void) G_GNUC_CONST;
+
+G_DECLARE_FINAL_TYPE(FlJsonMessageCodec,
+ fl_json_message_codec,
+ FL,
+ JSON_CODEC,
+ FlMessageCodec)
+
+/**
+ * FlJsonMessageCodec:
+ *
+ * #FlJsonMessageCodec is an #FlMessageCodec that implements the Flutter
+ * standard message encoding. This encodes and decodes #FlValue of type
+ * #FL_VALUE_TYPE_NULL, #FL_VALUE_TYPE_BOOL, #FL_VALUE_TYPE_INT,
+ * #FL_VALUE_TYPE_FLOAT, #FL_VALUE_TYPE_STRING, #FL_VALUE_TYPE_UINT8_LIST,
+ * #FL_VALUE_TYPE_INT32_LIST, #FL_VALUE_TYPE_INT64_LIST,
+ * #FL_VALUE_TYPE_FLOAT_LIST, #FL_VALUE_TYPE_LIST, and #FL_VALUE_TYPE_MAP
+ *
+ * #FlJsonMessageCodec matches the JSONMessageCodec class in the Flutter
+ * services library.
+ */
+
+/**
+ * fl_json_message_codec_new:
+ *
+ * Creates a #FlJsonMessageCodec.
+ *
+ * Returns: a new #FlJsonMessageCodec
+ */
+FlJsonMessageCodec* fl_json_message_codec_new();
+
+/**
+ * fl_json_message_codec_encode:
+ * @codec: a #FlJsonMessageCodec
+ * @value: value to encode
+ * @error: (allow-none): #GError location to store the error occurring, or %NULL
+ *
+ * Encode a value to a JSON string.
+ *
+ * Returns: a JSON representation of this value or %NULL on error.
+ */
+gchar* fl_json_message_codec_encode(FlJsonMessageCodec* codec,
+ FlValue* value,
+ GError** error);
+
+/**
+ * fl_json_message_codec_decode:
+ * @codec: a #FlJsonMessageCodec
+ * @text: UTF-8 text in JSON format
+ * @error: (allow-none): #GError location to store the error occurring, or %NULL
+ *
+ * Decode a value from a JSON string.
+ *
+ * Returns: a #FlValue or %NULL on error
+ */
+FlValue* fl_json_message_codec_decode(FlJsonMessageCodec* codec,
+ const gchar* text,
+ GError** error);
+
+G_END_DECLS
+
+#endif // FLUTTER_SHELL_PLATFORM_LINUX_FL_JSON_MESSAGE_CODEC_H_
diff --git a/shell/platform/linux/public/flutter_linux/flutter_linux.h b/shell/platform/linux/public/flutter_linux/flutter_linux.h
index cb869b0..b26e9ab 100644
--- a/shell/platform/linux/public/flutter_linux/flutter_linux.h
+++ b/shell/platform/linux/public/flutter_linux/flutter_linux.h
@@ -12,6 +12,7 @@
#include <flutter_linux/fl_binary_messenger.h>
#include <flutter_linux/fl_dart_project.h>
#include <flutter_linux/fl_engine.h>
+#include <flutter_linux/fl_json_message_codec.h>
#include <flutter_linux/fl_message_codec.h>
#include <flutter_linux/fl_standard_message_codec.h>
#include <flutter_linux/fl_string_codec.h>
