Reduce discrepancies between FlatbufferToJson versions
This:
* Causes NaNs to always be printed as "nan" or "-nan".
* Makes whitespace printing more consistent.
Additionally:
* Adds several TODOs regarding remaining discrepancies.
* Swaps an argument type to a const char * to improve overload
resolution.
Change-Id: Ibcd46d5d59ca607f96736c61d3159136a43c75ce
Signed-off-by: James Kuszmaul <james.kuszmaul@bluerivertech.com>
diff --git a/aos/flatbuffer_introspection.cc b/aos/flatbuffer_introspection.cc
index 4dd7f2a..163c281 100644
--- a/aos/flatbuffer_introspection.cc
+++ b/aos/flatbuffer_introspection.cc
@@ -61,7 +61,7 @@
void FloatToString(double val, reflection::BaseType type,
FastStringBuilder *out) {
if (std::isnan(val)) {
- out->Append("null");
+ out->Append(std::signbit(val) ? "-nan" : "nan");
return;
}
switch (type) {
@@ -228,6 +228,9 @@
}
out->AppendChar('[');
+ if (!wrap) {
+ out->AppendChar(' ');
+ }
for (flatbuffers::uoffset_t i = 0; i < vector->size(); ++i) {
if (i != 0) {
if (wrap) {
@@ -271,6 +274,8 @@
}
if (wrap) {
AddWrapping(out, tree_depth);
+ } else {
+ out->AppendChar(' ');
}
out->AppendChar(']');
} else {
@@ -327,6 +332,9 @@
}
out->AppendChar('{');
+ if (!wrap) {
+ out->AppendChar(' ');
+ }
for (const reflection::Field *field : *obj->fields()) {
// Check whether this object has the field populated (even for structs,
// which should have all fields populated)
@@ -355,6 +363,8 @@
if (wrap) {
AddWrapping(out, tree_depth);
+ } else {
+ out->AppendChar(' ');
}
out->AppendChar('}');
diff --git a/aos/flatbuffer_introspection_test.cc b/aos/flatbuffer_introspection_test.cc
index cc7d627..54c6f18 100644
--- a/aos/flatbuffer_introspection_test.cc
+++ b/aos/flatbuffer_introspection_test.cc
@@ -45,9 +45,9 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
EXPECT_EQ(out,
- "{\"foo_bool\": true, \"foo_byte\": -5, \"foo_int\": -20, "
+ "{ \"foo_bool\": true, \"foo_byte\": -5, \"foo_int\": -20, "
"\"foo_long\": -100, \"foo_short\": -10, \"foo_ubyte\": 5, "
- "\"foo_uint\": 20, \"foo_ulong\": 100, \"foo_ushort\": 10}");
+ "\"foo_uint\": 20, \"foo_ulong\": 100, \"foo_ushort\": 10 }");
}
TEST_F(FlatbufferIntrospectionTest, FloatTest) {
@@ -62,7 +62,7 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
EXPECT_EQ(out,
- "{\"foo_double\": 0.555555555555556, \"foo_float\": 0.333333}");
+ "{ \"foo_double\": 0.555555555555556, \"foo_float\": 0.333333 }");
}
TEST_F(FlatbufferIntrospectionTest, NanFloatTest) {
@@ -76,7 +76,7 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
- EXPECT_EQ(out, "{\"foo_double\": null, \"foo_float\": null}");
+ EXPECT_EQ(out, "{ \"foo_double\": nan, \"foo_float\": nan }");
}
TEST_F(FlatbufferIntrospectionTest, VectorScalarTest) {
@@ -129,18 +129,18 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
- EXPECT_EQ(
- out,
- "{\"vector_foo_bool\": [true, false, true, false], \"vector_foo_byte\": "
- "[-3, -2, -1, 0, 1, 2, 3], \"vector_foo_double\": [0, 0.111111111111111, "
- "0.222222222222222, 0.333333333333333], \"vector_foo_float\": [0, "
- "0.111111, 0.222222, 0.333333], \"vector_foo_int\": [-300, -200, -100, "
- "0, 100, 200, 300], \"vector_foo_long\": [-3000, -2000, -1000, 0, 1000, "
- "2000, 3000], \"vector_foo_short\": [-30, -20, -10, 0, 10, 20, 30], "
- "\"vector_foo_ubyte\": [0, 1, 2, 3, 4, 5, 6], \"vector_foo_uint\": [0, "
- "100, 200, 300, 400, 500, 600], \"vector_foo_ulong\": [0, 1000, 2000, "
- "3000, 4000, 5000, 6000], \"vector_foo_ushort\": [0, 10, 20, 30, 40, 50, "
- "60]}");
+ EXPECT_EQ(out,
+ "{ \"vector_foo_bool\": [ true, false, true, false ], "
+ "\"vector_foo_byte\": [ -3, -2, -1, 0, 1, 2, 3 ], "
+ "\"vector_foo_double\": [ 0, 0.111111111111111, 0.222222222222222, "
+ "0.333333333333333 ], \"vector_foo_float\": [ 0, 0.111111, "
+ "0.222222, 0.333333 ], \"vector_foo_int\": [ -300, -200, -100, 0, "
+ "100, 200, 300 ], \"vector_foo_long\": [ -3000, -2000, -1000, 0, "
+ "1000, 2000, 3000 ], \"vector_foo_short\": [ -30, -20, -10, 0, 10, "
+ "20, 30 ], \"vector_foo_ubyte\": [ 0, 1, 2, 3, 4, 5, 6 ], "
+ "\"vector_foo_uint\": [ 0, 100, 200, 300, 400, 500, 600 ], "
+ "\"vector_foo_ulong\": [ 0, 1000, 2000, 3000, 4000, 5000, 6000 ], "
+ "\"vector_foo_ushort\": [ 0, 10, 20, 30, 40, 50, 60 ] }");
}
TEST_F(FlatbufferIntrospectionTest, StringTest) {
@@ -155,7 +155,7 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
- EXPECT_EQ(out, "{\"foo_string\": \"I <3 FlatBuffers!\"}");
+ EXPECT_EQ(out, "{ \"foo_string\": \"I <3 FlatBuffers!\" }");
}
TEST_F(FlatbufferIntrospectionTest, EnumTest) {
@@ -168,7 +168,7 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
- EXPECT_EQ(out, "{\"foo_enum\": \"UShort\"}");
+ EXPECT_EQ(out, "{ \"foo_enum\": \"UShort\" }");
}
TEST_F(FlatbufferIntrospectionTest, EnumWithUnknownValueTest) {
@@ -183,7 +183,7 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
- EXPECT_EQ(out, "{\"foo_enum\": 123}");
+ EXPECT_EQ(out, "{ \"foo_enum\": 123 }");
}
TEST_F(FlatbufferIntrospectionTest, VectorStringTest) {
@@ -221,10 +221,11 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
- EXPECT_EQ(out,
- "{\"vector_foo_string\": [\"abc\", \"acb\"], \"vov\": {\"v\": "
- "[{\"str\": [\"abc\", \"acb\"]}, {\"str\": [\"bac\", \"bca\"]}, "
- "{\"str\": [\"cab\", \"cba\"]}]}}");
+ EXPECT_EQ(
+ out,
+ "{ \"vector_foo_string\": [ \"abc\", \"acb\" ], \"vov\": { \"v\": "
+ "[ { \"str\": [ \"abc\", \"acb\" ] }, { \"str\": [ \"bac\", \"bca\" ] }, "
+ "{ \"str\": [ \"cab\", \"cba\" ] } ] } }");
}
TEST_F(FlatbufferIntrospectionTest, TableTest) {
@@ -254,10 +255,10 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
EXPECT_EQ(out,
- "{\"foo_byte\": 5, \"foo_string\": \"Root Config String\", "
- "\"nested_config\": {\"foo_byte\": 10, \"foo_string\": \"Nested "
- "Config String\", \"vector_foo_byte\": [6, 7, 8, 9, 10]}, "
- "\"vector_foo_byte\": [0, 1, 2, 3, 4, 5]}");
+ "{ \"foo_byte\": 5, \"foo_string\": \"Root Config String\", "
+ "\"nested_config\": { \"foo_byte\": 10, \"foo_string\": \"Nested "
+ "Config String\", \"vector_foo_byte\": [ 6, 7, 8, 9, 10 ] }, "
+ "\"vector_foo_byte\": [ 0, 1, 2, 3, 4, 5 ] }");
}
TEST_F(FlatbufferIntrospectionTest, StructTest) {
@@ -275,8 +276,8 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
EXPECT_EQ(out,
- "{\"foo_struct\": {\"foo_byte\": 5, \"nested_struct\": "
- "{\"foo_byte\": 10}}}");
+ "{ \"foo_struct\": { \"foo_byte\": 5, \"nested_struct\": "
+ "{ \"foo_byte\": 10 } } }");
}
TEST_F(FlatbufferIntrospectionTest, VectorStructTest) {
@@ -295,9 +296,9 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
EXPECT_EQ(out,
- "{\"vector_foo_struct\": [{\"foo_byte\": 5, \"nested_struct\": "
- "{\"foo_byte\": 1}}, {\"foo_byte\": 10, \"nested_struct\": "
- "{\"foo_byte\": 1}}]}");
+ "{ \"vector_foo_struct\": [ { \"foo_byte\": 5, \"nested_struct\": "
+ "{ \"foo_byte\": 1 } }, { \"foo_byte\": 10, \"nested_struct\": "
+ "{ \"foo_byte\": 1 } } ] }");
}
TEST_F(FlatbufferIntrospectionTest, VectorEnumTest) {
@@ -313,7 +314,7 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
- EXPECT_EQ(out, "{\"vector_foo_enum\": [\"UShort\", \"Obj\", \"UInt\"]}");
+ EXPECT_EQ(out, "{ \"vector_foo_enum\": [ \"UShort\", \"Obj\", \"UInt\" ] }");
}
TEST_F(FlatbufferIntrospectionTest, StructEnumTest) {
@@ -328,7 +329,7 @@
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
- EXPECT_EQ(out, "{\"foo_struct_enum\": {\"foo_enum\": \"UShort\"}}");
+ EXPECT_EQ(out, "{ \"foo_struct_enum\": { \"foo_enum\": \"UShort\" } }");
}
TEST_F(FlatbufferIntrospectionTest, StringEscapeTest) {
@@ -342,7 +343,7 @@
builder.Finish(config_builder.Finish());
std::string out = FlatbufferToJson(schema_, builder.GetBufferPointer());
- EXPECT_EQ(out, "{\"foo_string\": \"\\\"\\\\\\b\\f\\n\\r\\t\"}");
+ EXPECT_EQ(out, "{ \"foo_string\": \"\\\"\\\\\\b\\f\\n\\r\\t\" }");
}
TEST_F(FlatbufferIntrospectionTest, TrimmedVector) {
@@ -362,7 +363,7 @@
std::string out =
FlatbufferToJson(schema_, builder.GetBufferPointer(),
{.multi_line = false, .max_vector_size = 100});
- EXPECT_EQ(out, "{\"vector_foo_int\": [ \"... 101 elements ...\" ]}");
+ EXPECT_EQ(out, "{ \"vector_foo_int\": [ \"... 101 elements ...\" ] }");
}
TEST_F(FlatbufferIntrospectionTest, MultilineTest) {
@@ -402,7 +403,7 @@
"{\n"
" \"foo_struct\": {\n"
" \"foo_byte\": 5,\n"
- " \"nested_struct\": {\"foo_byte\": 10}\n"
+ " \"nested_struct\": { \"foo_byte\": 10 }\n"
" }\n"
"}");
}
@@ -428,11 +429,11 @@
" \"vector_foo_struct\": [\n"
" {\n"
" \"foo_byte\": 5,\n"
- " \"nested_struct\": {\"foo_byte\": 1}\n"
+ " \"nested_struct\": { \"foo_byte\": 1 }\n"
" },\n"
" {\n"
" \"foo_byte\": 10,\n"
- " \"nested_struct\": {\"foo_byte\": 1}\n"
+ " \"nested_struct\": { \"foo_byte\": 1 }\n"
" }\n"
" ]\n"
"}");
@@ -464,10 +465,10 @@
EXPECT_EQ(out,
"{\n"
- " \"vector_foo_double\": [0, 0.111111111111111, "
- "0.222222222222222, 0.333333333333333],\n"
- " \"vector_foo_float\": [0, 0.111111, 0.222222, 0.333333],\n"
- " \"vector_foo_int\": [-300, -200, -100, 0, 100, 200, 300]\n"
+ " \"vector_foo_double\": [ 0, 0.111111111111111, "
+ "0.222222222222222, 0.333333333333333 ],\n"
+ " \"vector_foo_float\": [ 0, 0.111111, 0.222222, 0.333333 ],\n"
+ " \"vector_foo_int\": [ -300, -200, -100, 0, 100, 200, 300 ]\n"
"}");
}
diff --git a/aos/json_to_flatbuffer_test.cc b/aos/json_to_flatbuffer_test.cc
index 85e21d4..b6b2c04 100644
--- a/aos/json_to_flatbuffer_test.cc
+++ b/aos/json_to_flatbuffer_test.cc
@@ -11,6 +11,8 @@
class JsonToFlatbufferTest : public ::testing::Test {
public:
+ enum class TestReflection { kYes, kNo };
+
JsonToFlatbufferTest() {}
FlatbufferVector<reflection::Schema> Schema() {
@@ -18,14 +20,23 @@
ArtifactPath("aos/json_to_flatbuffer.bfbs"));
}
- bool JsonAndBack(const ::std::string str) { return JsonAndBack(str, str); }
+ // JsonAndBack tests using both the reflection::Schema* as well as the
+ // minireflect tables for both parsing and outputting JSON. However, there are
+ // currently minor discrepencies between how the JSON output works for the two
+ // modes, so some tests must manually disable testing of the
+ // FlatbufferToJson() overload that takes a reflection::Schema*.
+ bool JsonAndBack(const char *str, TestReflection test_reflection_to_json =
+ TestReflection::kYes) {
+ return JsonAndBack(str, str, test_reflection_to_json);
+ }
- bool JsonAndBack(const ::std::string in, const ::std::string out) {
- printf("Testing: %s\n", in.c_str());
+ bool JsonAndBack(
+ const char *in, const char *out,
+ TestReflection test_reflection_to_json = TestReflection::kYes) {
FlatbufferDetachedBuffer<Configuration> fb_typetable =
- JsonToFlatbuffer<Configuration>(in.data());
+ JsonToFlatbuffer<Configuration>(in);
FlatbufferDetachedBuffer<Configuration> fb_reflection =
- JsonToFlatbuffer(in.data(), FlatbufferType(&Schema().message()));
+ JsonToFlatbuffer(in, FlatbufferType(&Schema().message()));
if (fb_typetable.span().size() == 0) {
return false;
@@ -36,13 +47,24 @@
const ::std::string back_typetable = FlatbufferToJson(fb_typetable);
const ::std::string back_reflection = FlatbufferToJson(fb_reflection);
+ const ::std::string back_reflection_reflection =
+ FlatbufferToJson(&Schema().message(), fb_reflection.span().data());
- printf("Back to string via TypeTable: %s\n", back_typetable.c_str());
- printf("Back to string via reflection: %s\n", back_reflection.c_str());
+ printf("Back to table via TypeTable and to string via TypeTable: %s\n",
+ back_typetable.c_str());
+ printf("Back to table via reflection and to string via TypeTable: %s\n",
+ back_reflection.c_str());
+ if (test_reflection_to_json == TestReflection::kYes) {
+ printf("Back to table via reflection and to string via reflection: %s\n",
+ back_reflection_reflection.c_str());
+ }
- const bool as_expected = back_typetable == out && back_reflection == out;
+ const bool as_expected =
+ back_typetable == out && back_reflection == out &&
+ ((test_reflection_to_json == TestReflection::kNo) ||
+ (back_reflection_reflection == out));
if (!as_expected) {
- printf("But expected: %s\n", out.c_str());
+ printf("But expected: %s\n", out);
}
return as_expected;
}
@@ -71,8 +93,10 @@
EXPECT_TRUE(JsonAndBack("{ \"foo_long\": 5 }"));
EXPECT_TRUE(JsonAndBack("{ \"foo_ulong\": 5 }"));
- EXPECT_TRUE(JsonAndBack("{ \"foo_float\": 5.0 }"));
- EXPECT_TRUE(JsonAndBack("{ \"foo_double\": 5.0 }"));
+ // TODO(james): Make FlatbufferToJson() always print out integer
+ // floating-point numbers identically.
+ EXPECT_TRUE(JsonAndBack("{ \"foo_float\": 5.0 }", TestReflection::kNo));
+ EXPECT_TRUE(JsonAndBack("{ \"foo_double\": 5.0 }", TestReflection::kNo));
EXPECT_TRUE(JsonAndBack("{ \"foo_enum\": \"None\" }"));
EXPECT_TRUE(JsonAndBack("{ \"foo_enum\": \"UType\" }"));
@@ -93,7 +117,8 @@
EXPECT_TRUE(JsonAndBack(
"{ \"foo_struct_scalars\": { \"foo_float\": 1.234, \"foo_double\": "
"4.567, \"foo_int32\": -971, \"foo_uint32\": 4294967294, \"foo_int64\": "
- "-1030, \"foo_uint64\": 18446744073709551614 } }"));
+ "-1030, \"foo_uint64\": 18446744073709551614 } }",
+ TestReflection::kNo));
// Confirm that we parse integers into floating point fields correctly.
EXPECT_TRUE(JsonAndBack(
"{ \"foo_struct_scalars\": { \"foo_float\": 1, \"foo_double\": "
@@ -101,13 +126,15 @@
"5, \"foo_uint64\": 6 } }",
"{ \"foo_struct_scalars\": { \"foo_float\": 1.0, \"foo_double\": "
"2.0, \"foo_int32\": 3, \"foo_uint32\": 4, \"foo_int64\": "
- "5, \"foo_uint64\": 6 } }"));
+ "5, \"foo_uint64\": 6 } }",
+ TestReflection::kNo));
EXPECT_TRUE(JsonAndBack(
"{ \"vector_foo_struct_scalars\": [ { \"foo_float\": 1.234, "
"\"foo_double\": 4.567, \"foo_int32\": -971, \"foo_uint32\": 4294967294, "
"\"foo_int64\": -1030, \"foo_uint64\": 18446744073709551614 }, { "
"\"foo_float\": 2.0, \"foo_double\": 4.1, \"foo_int32\": 10, "
- "\"foo_uint32\": 13, \"foo_int64\": 15, \"foo_uint64\": 18 } ] }"));
+ "\"foo_uint32\": 13, \"foo_int64\": 15, \"foo_uint64\": 18 } ] }",
+ TestReflection::kNo));
EXPECT_TRUE(
JsonAndBack("{ \"foo_struct_enum\": { \"foo_enum\": \"UByte\" } }"));
EXPECT_TRUE(
@@ -160,14 +187,24 @@
// Tests that unicode is handled correctly
TEST_F(JsonToFlatbufferTest, Unicode) {
- EXPECT_TRUE(JsonAndBack("{ \"foo_string\": \"\\uF672\" }"));
- EXPECT_TRUE(JsonAndBack("{ \"foo_string\": \"\\uEFEF\" }"));
- EXPECT_TRUE(JsonAndBack("{ \"foo_string\": \"helloworld\\uD83E\\uDE94\" }"));
- EXPECT_TRUE(JsonAndBack("{ \"foo_string\": \"\\uD83C\\uDF32\" }"));
- EXPECT_FALSE(JsonAndBack("{ \"foo_string\": \"\\uP890\" }"));
- EXPECT_FALSE(JsonAndBack("{ \"foo_string\": \"\\u!FA8\" }"));
- EXPECT_FALSE(JsonAndBack("{ \"foo_string\": \"\\uF89\" }"));
- EXPECT_FALSE(JsonAndBack("{ \"foo_string\": \"\\uD83C\" }"));
+ // The reflection-based FlatbufferToJson outputs actual unicode rather than
+ // escaped code-points.
+ EXPECT_TRUE(
+ JsonAndBack("{ \"foo_string\": \"\\uF672\" }", TestReflection::kNo));
+ EXPECT_TRUE(
+ JsonAndBack("{ \"foo_string\": \"\\uEFEF\" }", TestReflection::kNo));
+ EXPECT_TRUE(JsonAndBack("{ \"foo_string\": \"helloworld\\uD83E\\uDE94\" }",
+ TestReflection::kNo));
+ EXPECT_TRUE(JsonAndBack("{ \"foo_string\": \"\\uD83C\\uDF32\" }",
+ TestReflection::kNo));
+ EXPECT_FALSE(
+ JsonAndBack("{ \"foo_string\": \"\\uP890\" }", TestReflection::kNo));
+ EXPECT_FALSE(
+ JsonAndBack("{ \"foo_string\": \"\\u!FA8\" }", TestReflection::kNo));
+ EXPECT_FALSE(
+ JsonAndBack("{ \"foo_string\": \"\\uF89\" }", TestReflection::kNo));
+ EXPECT_FALSE(
+ JsonAndBack("{ \"foo_string\": \"\\uD83C\" }", TestReflection::kNo));
}
// Tests that we can handle decimal points.
@@ -246,15 +283,19 @@
EXPECT_TRUE(JsonAndBack("{ \"vector_foo_ulong\": [ 9, 7, 1 ] }"));
EXPECT_TRUE(JsonAndBack("{ \"vector_foo_ulong\": [ ] }"));
- EXPECT_TRUE(JsonAndBack("{ \"vector_foo_float\": [ 9.0, 7.0, 1.0 ] }"));
+ EXPECT_TRUE(JsonAndBack("{ \"vector_foo_float\": [ 9.0, 7.0, 1.0 ] }",
+ TestReflection::kNo));
EXPECT_TRUE(JsonAndBack("{ \"vector_foo_float\": [ ] }"));
- EXPECT_TRUE(JsonAndBack("{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }"));
+ EXPECT_TRUE(JsonAndBack("{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }",
+ TestReflection::kNo));
EXPECT_TRUE(JsonAndBack("{ \"vector_foo_double\": [ ] }"));
EXPECT_TRUE(JsonAndBack("{ \"vector_foo_float\": [ 9, 7, 1 ] }",
- "{ \"vector_foo_float\": [ 9.0, 7.0, 1.0 ] }"));
+ "{ \"vector_foo_float\": [ 9.0, 7.0, 1.0 ] }",
+ TestReflection::kNo));
EXPECT_TRUE(JsonAndBack("{ \"vector_foo_double\": [ 9, 7, 1 ] }",
- "{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }"));
+ "{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }",
+ TestReflection::kNo));
EXPECT_TRUE(JsonAndBack("{ \"vector_foo_string\": [ \"bar\", \"baz\" ] }"));
EXPECT_TRUE(JsonAndBack("{ \"vector_foo_string\": [ ] }"));
@@ -295,7 +336,8 @@
/* foo */
"vector_foo_double": [ 9, 7, 1 ] /* foo */
} /* foo */)",
- "{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }"));
+ "{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }",
+ TestReflection::kNo));
}
// Tests that C++ style comments get stripped.
@@ -304,7 +346,8 @@
// foo
"vector_foo_double": [ 9, 7, 1 ] // foo
} // foo)",
- "{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }"));
+ "{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }",
+ TestReflection::kNo));
}
// Tests that mixed style comments get stripped.
@@ -316,7 +359,8 @@
}
// foo
/* foo */)",
- "{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }"));
+ "{ \"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }",
+ TestReflection::kNo));
}
// Tests that multiple arrays get properly handled.
@@ -325,7 +369,8 @@
JsonAndBack("{ \"vector_foo_float\": [ 9, 7, 1 ], \"vector_foo_double\": "
"[ 9, 7, 1 ] }",
"{ \"vector_foo_float\": [ 9.0, 7.0, 1.0 ], "
- "\"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }"));
+ "\"vector_foo_double\": [ 9.0, 7.0, 1.0 ] }",
+ TestReflection::kNo));
}
// Tests that multiple arrays get properly handled.