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.