diff --git a/tests/test.cpp b/tests/test.cpp
index c11053c..756c0ea 100644
--- a/tests/test.cpp
+++ b/tests/test.cpp
@@ -14,38 +14,29 @@
  * limitations under the License.
  */
 #include <cmath>
+#include <string>
 
 #include "flatbuffers/flatbuffers.h"
 #include "flatbuffers/idl.h"
 #include "flatbuffers/minireflect.h"
 #include "flatbuffers/registry.h"
 #include "flatbuffers/util.h"
-
-// clang-format off
-#ifdef FLATBUFFERS_CPP98_STL
-  namespace std {
-    using flatbuffers::unique_ptr;
-  }
-#endif
-// clang-format on
-
 #include "monster_test_generated.h"
 #include "namespace_test/namespace_test1_generated.h"
 #include "namespace_test/namespace_test2_generated.h"
-#include "union_vector/union_vector_generated.h"
-#include "monster_extra_generated.h"
 #include "optional_scalars_generated.h"
+#include "union_vector/union_vector_generated.h"
 #if !defined(_MSC_VER) || _MSC_VER >= 1700
 #  include "arrays_test_generated.h"
 #  include "evolution_test/evolution_v1_generated.h"
 #  include "evolution_test/evolution_v2_generated.h"
+#  include "monster_extra_generated.h"
 #endif
 
-#include "native_type_test_generated.h"
-#include "test_assert.h"
-
 #include "flatbuffers/flexbuffers.h"
 #include "monster_test_bfbs_generated.h"  // Generated using --bfbs-comments --bfbs-builtins --cpp --bfbs-gen-embed
+#include "native_type_test_generated.h"
+#include "test_assert.h"
 
 // clang-format off
 // Check that char* and uint8_t* are interoperable types.
@@ -63,8 +54,8 @@
 // clang-format on
 
 // Shortcuts for the infinity.
-static const auto infinityf = std::numeric_limits<float>::infinity();
-static const auto infinityd = std::numeric_limits<double>::infinity();
+static const auto infinity_f = std::numeric_limits<float>::infinity();
+static const auto infinity_d = std::numeric_limits<double>::infinity();
 
 using namespace MyGame::Example;
 
@@ -107,21 +98,9 @@
   Test tests[] = { Test(10, 20), Test(30, 40) };
   auto testv = builder.CreateVectorOfStructs(tests, 2);
 
-  // clang-format off
-  #ifndef FLATBUFFERS_CPP98_STL
-    // Create a vector of structures from a lambda.
-    auto testv2 = builder.CreateVectorOfStructs<Test>(
-          2, [&](size_t i, Test* s) -> void {
-            *s = tests[i];
-          });
-  #else
-    // Create a vector of structures using a plain old C++ function.
-    auto testv2 = builder.CreateVectorOfStructs<Test>(
-          2, [](size_t i, Test* s, void *state) -> void {
-            *s = (reinterpret_cast<Test*>(state))[i];
-          }, tests);
-  #endif  // FLATBUFFERS_CPP98_STL
-  // clang-format on
+  // Create a vector of structures from a lambda.
+  auto testv2 = builder.CreateVectorOfStructs<Test>(
+      2, [&](size_t i, Test *s) -> void { *s = tests[i]; });
 
   // create monster with very few fields set:
   // (same functionality as CreateMonster below, but sets fields manually)
@@ -157,6 +136,15 @@
   names2.push_back("mary");
   auto vecofstrings2 = builder.CreateVectorOfStrings(names2);
 
+  // Create many vectors of strings
+  std::vector<std::string> manyNames;
+  for (auto i = 0; i < 100; i++) { manyNames.push_back("john_doe"); }
+  auto manyNamesVec = builder.CreateVectorOfStrings(manyNames);
+  TEST_EQ(false, manyNamesVec.IsNull());
+  auto manyNamesVec2 =
+      builder.CreateVectorOfStrings(manyNames.cbegin(), manyNames.cend());
+  TEST_EQ(false, manyNamesVec2.IsNull());
+
   // Create an array of sorted tables, can be used with binary search when read:
   auto vecoftables = builder.CreateVectorOfSortedTables(mlocs, 3);
 
@@ -166,9 +154,18 @@
   abilities.push_back(Ability(4, 40));
   abilities.push_back(Ability(3, 30));
   abilities.push_back(Ability(2, 20));
-  abilities.push_back(Ability(1, 10));
+  abilities.push_back(Ability(0, 0));
   auto vecofstructs = builder.CreateVectorOfSortedStructs(&abilities);
 
+  flatbuffers::Offset<Stat> mlocs_stats[1];
+  auto miss = builder.CreateString("miss");
+  StatBuilder mb_miss(builder);
+  mb_miss.add_id(miss);
+  mb_miss.add_val(0);
+  mb_miss.add_count(0);  // key
+  mlocs_stats[0] = mb_miss.Finish();
+  auto vec_of_stats = builder.CreateVectorOfSortedTables(mlocs_stats, 1);
+
   // Create a nested FlatBuffer.
   // Nested FlatBuffers are stored in a ubyte vector, which can be convenient
   // since they can be memcpy'd around much easier than other FlatBuffer
@@ -195,7 +192,6 @@
   flexbuild.Int(1234);
   flexbuild.Finish();
   auto flex = builder.CreateVector(flexbuild.GetBuffer());
-
   // Test vector of enums.
   Color colors[] = { Color_Blue, Color_Green };
   // We use this special creation function because we have an array of
@@ -210,11 +206,12 @@
       testv, vecofstrings, vecoftables, 0, nested_flatbuffer_vector, 0, false,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 3.14159f, 3.0f, 0.0f, vecofstrings2,
       vecofstructs, flex, testv2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      AnyUniqueAliases_NONE, 0, AnyAmbiguousAliases_NONE, 0, vecofcolors);
+      AnyUniqueAliases_NONE, 0, AnyAmbiguousAliases_NONE, 0, vecofcolors,
+      MyGame::Example::Race_None, 0, vec_of_stats);
 
   FinishMonsterBuffer(builder, mloc);
 
-  // clang-format off
+// clang-format off
   #ifdef FLATBUFFERS_TEST_VERBOSE
   // print byte data for debugging:
   auto p = builder.GetBufferPointer();
@@ -236,9 +233,11 @@
                           bool pooled = true) {
   // First, verify the buffers integrity (optional)
   flatbuffers::Verifier verifier(flatbuf, length);
+  std::vector<uint8_t> flex_reuse_tracker;
+  verifier.SetFlexReuseTracker(&flex_reuse_tracker);
   TEST_EQ(VerifyMonsterBuffer(verifier), true);
 
-  // clang-format off
+// clang-format off
   #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
     std::vector<uint8_t> test_buff;
     test_buff.resize(length * 2);
@@ -281,7 +280,7 @@
   unsigned char inv_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
   // Check compatibilty of iterators with STL.
   std::vector<unsigned char> inv_vec(inventory->begin(), inventory->end());
-  int n = 0;
+  size_t n = 0;
   for (auto it = inventory->begin(); it != inventory->end(); ++it, ++n) {
     auto indx = it - inventory->begin();
     TEST_EQ(*it, inv_vec.at(indx));  // Use bounds-check.
@@ -361,11 +360,20 @@
       auto right = vecofstructs->Get(i + 1);
       TEST_EQ(true, (left->KeyCompareLessThan(right)));
     }
+    TEST_NOTNULL(vecofstructs->LookupByKey(0));  // test default value
     TEST_NOTNULL(vecofstructs->LookupByKey(3));
     TEST_EQ(static_cast<const Ability *>(nullptr),
             vecofstructs->LookupByKey(5));
   }
 
+  if (auto vec_of_stat = monster->scalar_key_sorted_tables()) {
+    auto stat_0 = vec_of_stat->LookupByKey(static_cast<uint16_t>(0u));
+    TEST_NOTNULL(stat_0);
+    TEST_NOTNULL(stat_0->id());
+    TEST_EQ(0, stat_0->count());
+    TEST_EQ_STR("miss", stat_0->id()->c_str());
+  }
+
   // Test nested FlatBuffers if available:
   auto nested_buffer = monster->testnestedflatbuffer();
   if (nested_buffer) {
@@ -473,52 +481,22 @@
   TEST_EQ(first->hp(), 0);
   first->mutate_hp(1000);
 
+  // Mutate via LookupByKey
+  TEST_NOTNULL(tables->MutableLookupByKey("Barney"));
+  TEST_EQ(static_cast<Monster *>(nullptr),
+          tables->MutableLookupByKey("DoesntExist"));
+  TEST_EQ(tables->MutableLookupByKey("Barney")->hp(), 1000);
+  TEST_EQ(tables->MutableLookupByKey("Barney")->mutate_hp(0), true);
+  TEST_EQ(tables->LookupByKey("Barney")->hp(), 0);
+  TEST_EQ(tables->MutableLookupByKey("Barney")->mutate_hp(1000), true);
+
   // Run the verifier and the regular test to make sure we didn't trample on
   // anything.
   AccessFlatBufferTest(flatbuf, length);
 }
 
-// Unpack a FlatBuffer into objects.
-void ObjectFlatBuffersTest(uint8_t *flatbuf) {
-  // Optional: we can specify resolver and rehasher functions to turn hashed
-  // strings into object pointers and back, to implement remote references
-  // and such.
-  auto resolver = flatbuffers::resolver_function_t(
-      [](void **pointer_adr, flatbuffers::hash_value_t hash) {
-        (void)pointer_adr;
-        (void)hash;
-        // Don't actually do anything, leave variable null.
-      });
-  auto rehasher = flatbuffers::rehasher_function_t(
-      [](void *pointer) -> flatbuffers::hash_value_t {
-        (void)pointer;
-        return 0;
-      });
-
-  // Turn a buffer into C++ objects.
-  auto monster1 = UnPackMonster(flatbuf, &resolver);
-
-  // Re-serialize the data.
-  flatbuffers::FlatBufferBuilder fbb1;
-  fbb1.Finish(CreateMonster(fbb1, monster1.get(), &rehasher),
-              MonsterIdentifier());
-
-  // Unpack again, and re-serialize again.
-  auto monster2 = UnPackMonster(fbb1.GetBufferPointer(), &resolver);
-  flatbuffers::FlatBufferBuilder fbb2;
-  fbb2.Finish(CreateMonster(fbb2, monster2.get(), &rehasher),
-              MonsterIdentifier());
-
-  // Now we've gone full round-trip, the two buffers should match.
-  auto len1 = fbb1.GetSize();
-  auto len2 = fbb2.GetSize();
-  TEST_EQ(len1, len2);
-  TEST_EQ(memcmp(fbb1.GetBufferPointer(), fbb2.GetBufferPointer(), len1), 0);
-
-  // Test it with the original buffer test to make sure all data survived.
-  AccessFlatBufferTest(fbb2.GetBufferPointer(), len2, false);
-
-  // Test accessing fields, similar to AccessFlatBufferTest above.
+// Utility function to check a Monster object.
+void CheckMonsterObject(MonsterT *monster2) {
   TEST_EQ(monster2->hp, 80);
   TEST_EQ(monster2->mana, 150);  // default
   TEST_EQ_STR(monster2->name.c_str(), "MyMonster");
@@ -565,6 +543,62 @@
   TEST_EQ(tests[1].b(), 40);
 }
 
+// Unpack a FlatBuffer into objects.
+void ObjectFlatBuffersTest(uint8_t *flatbuf) {
+  // Optional: we can specify resolver and rehasher functions to turn hashed
+  // strings into object pointers and back, to implement remote references
+  // and such.
+  auto resolver = flatbuffers::resolver_function_t(
+      [](void **pointer_adr, flatbuffers::hash_value_t hash) {
+        (void)pointer_adr;
+        (void)hash;
+        // Don't actually do anything, leave variable null.
+      });
+  auto rehasher = flatbuffers::rehasher_function_t(
+      [](void *pointer) -> flatbuffers::hash_value_t {
+        (void)pointer;
+        return 0;
+      });
+
+  // Turn a buffer into C++ objects.
+  auto monster1 = UnPackMonster(flatbuf, &resolver);
+
+  // Re-serialize the data.
+  flatbuffers::FlatBufferBuilder fbb1;
+  fbb1.Finish(CreateMonster(fbb1, monster1.get(), &rehasher),
+              MonsterIdentifier());
+
+  // Unpack again, and re-serialize again.
+  auto monster2 = UnPackMonster(fbb1.GetBufferPointer(), &resolver);
+  flatbuffers::FlatBufferBuilder fbb2;
+  fbb2.Finish(CreateMonster(fbb2, monster2.get(), &rehasher),
+              MonsterIdentifier());
+
+  // Now we've gone full round-trip, the two buffers should match.
+  const auto len1 = fbb1.GetSize();
+  const auto len2 = fbb2.GetSize();
+  TEST_EQ(len1, len2);
+  TEST_EQ(memcmp(fbb1.GetBufferPointer(), fbb2.GetBufferPointer(), len1), 0);
+
+  // Test it with the original buffer test to make sure all data survived.
+  AccessFlatBufferTest(fbb2.GetBufferPointer(), len2, false);
+
+  // Test accessing fields, similar to AccessFlatBufferTest above.
+  CheckMonsterObject(monster2.get());
+
+  // Test object copy.
+  auto monster3 = *monster2;
+  flatbuffers::FlatBufferBuilder fbb3;
+  fbb3.Finish(CreateMonster(fbb3, &monster3, &rehasher), MonsterIdentifier());
+  const auto len3 = fbb3.GetSize();
+  TEST_EQ(len2, len3);
+  TEST_EQ(memcmp(fbb2.GetBufferPointer(), fbb3.GetBufferPointer(), len2), 0);
+  // Delete monster1 and monster2, then test accessing fields in monster3.
+  monster1.reset();
+  monster2.reset();
+  CheckMonsterObject(&monster3);
+}
+
 // Prefix a FlatBuffer with a size field.
 void SizePrefixedTest() {
   // Create size prefixed buffer.
@@ -584,7 +618,7 @@
 }
 
 void TriviallyCopyableTest() {
-  // clang-format off
+// clang-format off
   #if __GNUG__ && __GNUC__ < 5
     TEST_EQ(__has_trivial_copy(Vec3), true);
   #else
@@ -678,7 +712,7 @@
   std::memcpy(&b, &v, sizeof(T));
   return ((b & qnan_base) == qnan_base);
 }
-#if defined(__mips__) || defined(__hppa__)
+#  if defined(__mips__) || defined(__hppa__)
 static bool is_quiet_nan(float v) {
   return is_quiet_nan_impl<float, uint32_t, 0x7FC00000u>(v) ||
          is_quiet_nan_impl<float, uint32_t, 0x7FBFFFFFu>(v);
@@ -687,19 +721,19 @@
   return is_quiet_nan_impl<double, uint64_t, 0x7FF8000000000000ul>(v) ||
          is_quiet_nan_impl<double, uint64_t, 0x7FF7FFFFFFFFFFFFu>(v);
 }
-#else
+#  else
 static bool is_quiet_nan(float v) {
   return is_quiet_nan_impl<float, uint32_t, 0x7FC00000u>(v);
 }
 static bool is_quiet_nan(double v) {
   return is_quiet_nan_impl<double, uint64_t, 0x7FF8000000000000ul>(v);
 }
-#endif
+#  endif
 
 void TestMonsterExtraFloats() {
   TEST_EQ(is_quiet_nan(1.0), false);
-  TEST_EQ(is_quiet_nan(infinityd), false);
-  TEST_EQ(is_quiet_nan(-infinityf), false);
+  TEST_EQ(is_quiet_nan(infinity_d), false);
+  TEST_EQ(is_quiet_nan(-infinity_f), false);
   TEST_EQ(is_quiet_nan(std::numeric_limits<float>::quiet_NaN()), true);
   TEST_EQ(is_quiet_nan(std::numeric_limits<double>::quiet_NaN()), true);
 
@@ -727,12 +761,12 @@
   TEST_NOTNULL(def_extra);
   TEST_EQ(is_quiet_nan(def_extra->f0()), true);
   TEST_EQ(is_quiet_nan(def_extra->f1()), true);
-  TEST_EQ(def_extra->f2(), +infinityf);
-  TEST_EQ(def_extra->f3(), -infinityf);
+  TEST_EQ(def_extra->f2(), +infinity_f);
+  TEST_EQ(def_extra->f3(), -infinity_f);
   TEST_EQ(is_quiet_nan(def_extra->d0()), true);
   TEST_EQ(is_quiet_nan(def_extra->d1()), true);
-  TEST_EQ(def_extra->d2(), +infinityd);
-  TEST_EQ(def_extra->d3(), -infinityd);
+  TEST_EQ(def_extra->d2(), +infinity_d);
+  TEST_EQ(def_extra->d3(), -infinity_d);
   std::string jsongen;
   auto result = GenerateText(parser, def_obj, &jsongen);
   TEST_EQ(result, true);
@@ -758,23 +792,23 @@
   TEST_NOTNULL(extra);
   TEST_EQ(is_quiet_nan(extra->f0()), true);
   TEST_EQ(is_quiet_nan(extra->f1()), true);
-  TEST_EQ(extra->f2(), +infinityf);
-  TEST_EQ(extra->f3(), -infinityf);
+  TEST_EQ(extra->f2(), +infinity_f);
+  TEST_EQ(extra->f3(), -infinity_f);
   TEST_EQ(is_quiet_nan(extra->d0()), true);
-  TEST_EQ(extra->d1(), +infinityd);
-  TEST_EQ(extra->d2(), -infinityd);
+  TEST_EQ(extra->d1(), +infinity_d);
+  TEST_EQ(extra->d2(), -infinity_d);
   TEST_EQ(is_quiet_nan(extra->d3()), true);
   TEST_NOTNULL(extra->fvec());
   TEST_EQ(extra->fvec()->size(), 4);
   TEST_EQ(extra->fvec()->Get(0), 1.0f);
-  TEST_EQ(extra->fvec()->Get(1), -infinityf);
-  TEST_EQ(extra->fvec()->Get(2), +infinityf);
+  TEST_EQ(extra->fvec()->Get(1), -infinity_f);
+  TEST_EQ(extra->fvec()->Get(2), +infinity_f);
   TEST_EQ(is_quiet_nan(extra->fvec()->Get(3)), true);
   TEST_NOTNULL(extra->dvec());
   TEST_EQ(extra->dvec()->size(), 4);
   TEST_EQ(extra->dvec()->Get(0), 2.0);
-  TEST_EQ(extra->dvec()->Get(1), +infinityd);
-  TEST_EQ(extra->dvec()->Get(2), -infinityd);
+  TEST_EQ(extra->dvec()->Get(1), +infinity_d);
+  TEST_EQ(extra->dvec()->Get(2), -infinity_d);
   TEST_EQ(is_quiet_nan(extra->dvec()->Get(3)), true);
 }
 #else
@@ -892,7 +926,56 @@
   // Make sure the schema is what we expect it to be.
   auto &schema = *reflection::GetSchema(bfbsfile.c_str());
   auto root_table = schema.root_table();
+
+  // Check the declaration files.
   TEST_EQ_STR(root_table->name()->c_str(), "MyGame.Example.Monster");
+  TEST_EQ_STR(root_table->declaration_file()->c_str(), "//monster_test.fbs");
+  TEST_EQ_STR(
+      schema.objects()->LookupByKey("TableA")->declaration_file()->c_str(),
+      "//include_test/include_test1.fbs");
+  TEST_EQ_STR(schema.objects()
+                  ->LookupByKey("MyGame.OtherNameSpace.Unused")
+                  ->declaration_file()
+                  ->c_str(),
+              "//include_test/sub/include_test2.fbs");
+  TEST_EQ_STR(schema.enums()
+                  ->LookupByKey("MyGame.OtherNameSpace.FromInclude")
+                  ->declaration_file()
+                  ->c_str(),
+              "//include_test/sub/include_test2.fbs");
+
+  // Check scheam filenames and their includes.
+  TEST_EQ(schema.fbs_files()->size(), 3);
+
+  const auto fbs0 = schema.fbs_files()->Get(0);
+  TEST_EQ_STR(fbs0->filename()->c_str(), "//include_test/include_test1.fbs");
+  const auto fbs0_includes = fbs0->included_filenames();
+  TEST_EQ(fbs0_includes->size(), 2);
+
+  // TODO(caspern): Should we force or disallow inclusion of self?
+  TEST_EQ_STR(fbs0_includes->Get(0)->c_str(),
+              "//include_test/include_test1.fbs");
+  TEST_EQ_STR(fbs0_includes->Get(1)->c_str(),
+              "//include_test/sub/include_test2.fbs");
+
+  const auto fbs1 = schema.fbs_files()->Get(1);
+  TEST_EQ_STR(fbs1->filename()->c_str(),
+              "//include_test/sub/include_test2.fbs");
+  const auto fbs1_includes = fbs1->included_filenames();
+  TEST_EQ(fbs1_includes->size(), 2);
+  TEST_EQ_STR(fbs1_includes->Get(0)->c_str(),
+              "//include_test/include_test1.fbs");
+  TEST_EQ_STR(fbs1_includes->Get(1)->c_str(),
+              "//include_test/sub/include_test2.fbs");
+
+  const auto fbs2 = schema.fbs_files()->Get(2);
+  TEST_EQ_STR(fbs2->filename()->c_str(), "//monster_test.fbs");
+  const auto fbs2_includes = fbs2->included_filenames();
+  TEST_EQ(fbs2_includes->size(), 1);
+  TEST_EQ_STR(fbs2_includes->Get(0)->c_str(),
+              "//include_test/include_test1.fbs");
+
+  // Check Root table fields
   auto fields = root_table->fields();
   auto hp_field_ptr = fields->LookupByKey("hp");
   TEST_NOTNULL(hp_field_ptr);
@@ -986,9 +1069,8 @@
   // Get the root.
   // This time we wrap the result from GetAnyRoot in a smartpointer that
   // will keep rroot valid as resizingbuf resizes.
-  auto rroot = flatbuffers::piv(
-      flatbuffers::GetAnyRoot(flatbuffers::vector_data(resizingbuf)),
-      resizingbuf);
+  auto rroot = flatbuffers::piv(flatbuffers::GetAnyRoot(resizingbuf.data()),
+                                resizingbuf);
   SetString(schema, "totally new string", GetFieldS(**rroot, name_field),
             &resizingbuf);
   // Here resizingbuf has changed, but rroot is still valid.
@@ -1032,13 +1114,12 @@
   TEST_EQ_STR(rtestarrayofstring->Get(2)->c_str(), "hank");
   // Test integrity of all resize operations above.
   flatbuffers::Verifier resize_verifier(
-      reinterpret_cast<const uint8_t *>(flatbuffers::vector_data(resizingbuf)),
+      reinterpret_cast<const uint8_t *>(resizingbuf.data()),
       resizingbuf.size());
   TEST_EQ(VerifyMonsterBuffer(resize_verifier), true);
 
   // Test buffer is valid using reflection as well
-  TEST_EQ(flatbuffers::Verify(schema, *schema.root_table(),
-                              flatbuffers::vector_data(resizingbuf),
+  TEST_EQ(flatbuffers::Verify(schema, *schema.root_table(), resizingbuf.data(),
                               resizingbuf.size()),
           true);
 
@@ -1088,12 +1169,13 @@
       "4, 0, 6, 0, 8, 0, 12, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 13, 0, 0, 0, 78, "
       "101, 115, 116, 101, 100, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0 ], "
       "testarrayofstring2: [ \"jane\", \"mary\" ], "
-      "testarrayofsortedstruct: [ { id: 1, distance: 10 }, "
+      "testarrayofsortedstruct: [ { id: 0, distance: 0 }, "
       "{ id: 2, distance: 20 }, { id: 3, distance: 30 }, "
       "{ id: 4, distance: 40 } ], "
       "flex: [ 210, 4, 5, 2 ], "
       "test5: [ { a: 10, b: 20 }, { a: 30, b: 40 } ], "
-      "vector_of_enums: [ Blue, Green ] "
+      "vector_of_enums: [ Blue, Green ], "
+      "scalar_key_sorted_tables: [ { id: \"miss\" } ] "
       "}");
 
   Test test(16, 32);
@@ -1280,9 +1362,13 @@
 
   // Ensure generated file is parsable.
   flatbuffers::Parser parser2;
-  TEST_EQ(
-      parser2.Parse(import_fbs.c_str(), include_directories, "imported.fbs"),
-      true);
+  // Since `imported.fbs` isn't in the filesystem AbsolutePath can't figure it
+  // out by itself. We manually construct it so Parser works.
+  std::string imported_fbs = flatbuffers::PosixPath(
+      flatbuffers::AbsolutePath(protopath) + "/imported.fbs");
+  TEST_EQ(parser2.Parse(import_fbs.c_str(), include_directories,
+                        imported_fbs.c_str()),
+          true);
   TEST_EQ(parser2.Parse(fbs.c_str(), nullptr), true);
   TEST_EQ_STR(fbs.c_str(), goldenfile.c_str());
 
@@ -1296,7 +1382,8 @@
 
   // Ensure generated file is parsable.
   flatbuffers::Parser parser4;
-  TEST_EQ(parser4.Parse(import_fbs.c_str(), nullptr, "imported.fbs"), true);
+  TEST_EQ(parser4.Parse(import_fbs.c_str(), nullptr, imported_fbs.c_str()),
+          true);
   TEST_EQ(parser4.Parse(fbs_union.c_str(), nullptr), true);
   TEST_EQ_STR(fbs_union.c_str(), goldenunionfile.c_str());
 }
@@ -1308,6 +1395,90 @@
   TEST_EQ(read, val);
 }
 
+void UtilConvertCase() {
+  {
+    std::vector<std::tuple<std::string, flatbuffers::Case, std::string>>
+        cases = {
+          // Tests for the common cases
+          { "the_quick_brown_fox", flatbuffers::Case::kUpperCamel,
+            "TheQuickBrownFox" },
+          { "the_quick_brown_fox", flatbuffers::Case::kLowerCamel,
+            "theQuickBrownFox" },
+          { "the_quick_brown_fox", flatbuffers::Case::kSnake,
+            "the_quick_brown_fox" },
+          { "the_quick_brown_fox", flatbuffers::Case::kScreamingSnake,
+            "THE_QUICK_BROWN_FOX" },
+          { "the_quick_brown_fox", flatbuffers::Case::kAllLower,
+            "the_quick_brown_fox" },
+          { "the_quick_brown_fox", flatbuffers::Case::kAllUpper,
+            "THE_QUICK_BROWN_FOX" },
+          { "the_quick_brown_fox", flatbuffers::Case::kUnknown,
+            "the_quick_brown_fox" },
+          { "the_quick_brown_fox", flatbuffers::Case::kKeep,
+            "the_quick_brown_fox" },
+
+          // Tests for some snake_cases where the _ is oddly placed or missing.
+          { "single", flatbuffers::Case::kUpperCamel, "Single" },
+          { "Single", flatbuffers::Case::kUpperCamel, "Single" },
+          { "_leading", flatbuffers::Case::kUpperCamel, "_leading" },
+          { "trailing_", flatbuffers::Case::kUpperCamel, "Trailing_" },
+          { "double__underscore", flatbuffers::Case::kUpperCamel,
+            "Double_underscore" },
+          { "single", flatbuffers::Case::kLowerCamel, "single" },
+          { "Single", flatbuffers::Case::kLowerCamel, "Single" },
+          { "_leading", flatbuffers::Case::kLowerCamel, "Leading" },
+          { "trailing_", flatbuffers::Case::kLowerCamel, "trailing_" },
+          { "double__underscore", flatbuffers::Case::kLowerCamel,
+            "double_underscore" },
+
+          // Tests for some output snake_cases
+          { "single", flatbuffers::Case::kSnake, "single" },
+          { "single", flatbuffers::Case::kScreamingSnake, "SINGLE" },
+          { "_leading", flatbuffers::Case::kScreamingSnake, "_LEADING" },
+          { "trailing_", flatbuffers::Case::kScreamingSnake, "TRAILING_" },
+          { "double__underscore", flatbuffers::Case::kScreamingSnake,
+            "DOUBLE__UNDERSCORE" },
+        };
+
+    for (auto &test_case : cases) {
+      TEST_EQ(std::get<2>(test_case),
+              flatbuffers::ConvertCase(std::get<0>(test_case),
+                                       std::get<1>(test_case)));
+    }
+  }
+
+  // Tests for the non snake_case inputs.
+  {
+    std::vector<std::tuple<flatbuffers::Case, std::string, flatbuffers::Case,
+                           std::string>>
+        cases = {
+          { flatbuffers::Case::kUpperCamel, "TheQuickBrownFox",
+            flatbuffers::Case::kSnake, "the_quick_brown_fox" },
+          { flatbuffers::Case::kLowerCamel, "theQuickBrownFox",
+            flatbuffers::Case::kSnake, "the_quick_brown_fox" },
+          { flatbuffers::Case::kSnake, "the_quick_brown_fox",
+            flatbuffers::Case::kSnake, "the_quick_brown_fox" },
+          { flatbuffers::Case::kScreamingSnake, "THE_QUICK_BROWN_FOX",
+            flatbuffers::Case::kSnake, "THE_QUICK_BROWN_FOX" },
+          { flatbuffers::Case::kAllUpper, "SINGLE", flatbuffers::Case::kSnake,
+            "SINGLE" },
+          { flatbuffers::Case::kAllLower, "single", flatbuffers::Case::kSnake,
+            "single" },
+          { flatbuffers::Case::kUpperCamel, "ABCtest",
+            flatbuffers::Case::kSnake, "abctest" },
+          { flatbuffers::Case::kUpperCamel, "tHe_qUiCk_BrOwN_fOx",
+            flatbuffers::Case::kKeep, "tHe_qUiCk_BrOwN_fOx" },
+        };
+
+    for (auto &test_case : cases) {
+      TEST_EQ(std::get<3>(test_case),
+              flatbuffers::ConvertCase(std::get<1>(test_case),
+                                       std::get<2>(test_case),
+                                       std::get<0>(test_case)));
+    }
+  }
+}
+
 // Low level stress/fuzz test: serialize/deserialize a variety of
 // different kinds of data in different combinations
 void FuzzTest1() {
@@ -1419,7 +1590,7 @@
     }
   };
 
-  // clang-format off
+// clang-format off
   #define AddToSchemaAndInstances(schema_add, instance_add) \
     RndDef::Add(definitions, schema, instances_per_definition, \
                 schema_add, instance_add, definition)
@@ -1526,7 +1697,9 @@
           }
       }
       AddToSchemaAndInstances(deprecated ? "(deprecated);\n" : ";\n",
-                              deprecated ? "" : is_last_field ? "\n" : ",\n");
+                              deprecated      ? ""
+                              : is_last_field ? "\n"
+                                              : ",\n");
     }
     AddToSchemaAndInstances("}\n\n", "}");
   }
@@ -1571,7 +1744,7 @@
     TEST_NOTNULL(nullptr);  //-V501 (this comment supresses CWE-570 warning)
   }
 
-  // clang-format off
+// clang-format off
   #ifdef FLATBUFFERS_TEST_VERBOSE
     TEST_OUTPUT_LINE("%dk schema tested with %dk of json\n",
                      static_cast<int>(schema.length() / 1024),
@@ -1625,7 +1798,6 @@
   TestError("table X { Y:int; Y:int; }", "field already");
   TestError("table Y {} table X { Y:int; }", "same as table");
   TestError("struct X { Y:string; }", "only scalar");
-  TestError("table X { Y:string = \"\"; }", "default values");
   TestError("struct X { a:uint = 42; }", "default values");
   TestError("enum Y:byte { Z = 1 } table X { y:Y; }", "not part of enum");
   TestError("struct X { Y:int (deprecated); }", "deprecate");
@@ -1649,6 +1821,12 @@
   TestError("enum X:byte { Y, Y }", "value already");
   TestError("enum X:byte { Y=2, Z=2 }", "unique");
   TestError("table X { Y:int; } table X {", "datatype already");
+  TestError("table X { } union X { }", "datatype already");
+  TestError("union X { } table X { }", "datatype already");
+  TestError("namespace A; table X { } namespace A; union X { }",
+            "datatype already");
+  TestError("namespace A; union X { } namespace A; table X { }",
+            "datatype already");
   TestError("struct X (force_align: 7) { Y:int; }", "force_align");
   TestError("struct X {}", "size 0");
   TestError("{}", "no root");
@@ -1670,6 +1848,15 @@
             "may contain only scalar or struct fields");
   // Non-snake case field names
   TestError("table X { Y: int; } root_type Y: {Y:1.0}", "snake_case");
+  // Complex defaults
+  TestError("table X { y: string = 1; }", "expecting: string");
+  TestError("table X { y: string = []; }", " Cannot assign token");
+  TestError("table X { y: [int] = [1]; }", "Expected `]`");
+  TestError("table X { y: [int] = [; }", "Expected `]`");
+  TestError("table X { y: [int] = \"\"; }", "type mismatch");
+  // An identifier can't start from sign (+|-)
+  TestError("table X { -Y: int; } root_type Y: {Y:1.0}", "identifier");
+  TestError("table X { +Y: int; } root_type Y: {Y:1.0}", "identifier");
 }
 
 template<typename T>
@@ -1967,10 +2154,10 @@
 
 void ValidFloatTest() {
   // check rounding to infinity
-  TEST_EQ(TestValue<float>("{ y:+3.4029e+38 }", "float"), +infinityf);
-  TEST_EQ(TestValue<float>("{ y:-3.4029e+38 }", "float"), -infinityf);
-  TEST_EQ(TestValue<double>("{ y:+1.7977e+308 }", "double"), +infinityd);
-  TEST_EQ(TestValue<double>("{ y:-1.7977e+308 }", "double"), -infinityd);
+  TEST_EQ(TestValue<float>("{ y:+3.4029e+38 }", "float"), +infinity_f);
+  TEST_EQ(TestValue<float>("{ y:-3.4029e+38 }", "float"), -infinity_f);
+  TEST_EQ(TestValue<double>("{ y:+1.7977e+308 }", "double"), +infinity_d);
+  TEST_EQ(TestValue<double>("{ y:-1.7977e+308 }", "double"), -infinity_d);
 
   TEST_EQ(
       FloatCompare(TestValue<float>("{ y:0.0314159e+2 }", "float"), 3.14159f),
@@ -2004,17 +2191,21 @@
   TEST_EQ(std::isnan(TestValue<double>("{ y:nan }", "double")), true);
   TEST_EQ(std::isnan(TestValue<float>("{ y:nan }", "float")), true);
   TEST_EQ(std::isnan(TestValue<float>("{ y:\"nan\" }", "float")), true);
+  TEST_EQ(std::isnan(TestValue<float>("{ y:\"+nan\" }", "float")), true);
+  TEST_EQ(std::isnan(TestValue<float>("{ y:\"-nan\" }", "float")), true);
   TEST_EQ(std::isnan(TestValue<float>("{ y:+nan }", "float")), true);
   TEST_EQ(std::isnan(TestValue<float>("{ y:-nan }", "float")), true);
   TEST_EQ(std::isnan(TestValue<float>(nullptr, "float=nan")), true);
   TEST_EQ(std::isnan(TestValue<float>(nullptr, "float=-nan")), true);
   // check inf
-  TEST_EQ(TestValue<float>("{ y:inf }", "float"), infinityf);
-  TEST_EQ(TestValue<float>("{ y:\"inf\" }", "float"), infinityf);
-  TEST_EQ(TestValue<float>("{ y:+inf }", "float"), infinityf);
-  TEST_EQ(TestValue<float>("{ y:-inf }", "float"), -infinityf);
-  TEST_EQ(TestValue<float>(nullptr, "float=inf"), infinityf);
-  TEST_EQ(TestValue<float>(nullptr, "float=-inf"), -infinityf);
+  TEST_EQ(TestValue<float>("{ y:inf }", "float"), infinity_f);
+  TEST_EQ(TestValue<float>("{ y:\"inf\" }", "float"), infinity_f);
+  TEST_EQ(TestValue<float>("{ y:\"-inf\" }", "float"), -infinity_f);
+  TEST_EQ(TestValue<float>("{ y:\"+inf\" }", "float"), infinity_f);
+  TEST_EQ(TestValue<float>("{ y:+inf }", "float"), infinity_f);
+  TEST_EQ(TestValue<float>("{ y:-inf }", "float"), -infinity_f);
+  TEST_EQ(TestValue<float>(nullptr, "float=inf"), infinity_f);
+  TEST_EQ(TestValue<float>(nullptr, "float=-inf"), -infinity_f);
   TestValue<double>(
       "{ y: [0.2, .2, 1.0, -1.0, -2., 2., 1e0, -1e0, 1.0e0, -1.0e0, -3.e2, "
       "3.0e2] }",
@@ -2134,6 +2325,15 @@
   TEST_EQ(ok, true);
   // Test root table
   const Monster *monster = GetMonster(parser.builder_.GetBufferPointer());
+  const auto abilities = monster->testarrayofsortedstruct();
+  TEST_EQ(abilities->size(), 3);
+  TEST_EQ(abilities->Get(0)->id(), 0);
+  TEST_EQ(abilities->Get(0)->distance(), 45);
+  TEST_EQ(abilities->Get(1)->id(), 1);
+  TEST_EQ(abilities->Get(1)->distance(), 21);
+  TEST_EQ(abilities->Get(2)->id(), 5);
+  TEST_EQ(abilities->Get(2)->distance(), 12);
+
   std::string jsongen;
   auto result = GenerateTextFromTable(parser, monster, "MyGame.Example.Monster",
                                       &jsongen);
@@ -2475,6 +2675,49 @@
           true);
 }
 
+void ValidSameNameDifferentNamespaceTest() {
+  // Duplicate table names in different namespaces must be parsable
+  TEST_ASSERT(flatbuffers::Parser().Parse(
+      "namespace A; table X {} namespace B; table X {}"));
+  // Duplicate union names in different namespaces must be parsable
+  TEST_ASSERT(flatbuffers::Parser().Parse(
+      "namespace A; union X {} namespace B; union X {}"));
+  // Clashing table and union names in different namespaces must be parsable
+  TEST_ASSERT(flatbuffers::Parser().Parse(
+      "namespace A; table X {} namespace B; union X {}"));
+  TEST_ASSERT(flatbuffers::Parser().Parse(
+      "namespace A; union X {} namespace B; table X {}"));
+}
+
+void MultiFileNameClashTest() {
+  const auto name_clash_path =
+      flatbuffers::ConCatPathFileName(test_data_path, "name_clash_test");
+  const char *include_directories[] = { name_clash_path.c_str() };
+
+  // Load valid 2 file Flatbuffer schema
+  const auto valid_path =
+      flatbuffers::ConCatPathFileName(name_clash_path, "valid_test1.fbs");
+  std::string valid_schema;
+  TEST_ASSERT(flatbuffers::LoadFile(valid_path.c_str(), false, &valid_schema));
+  // Clashing table and union names in different namespaces must be parsable
+  TEST_ASSERT(
+      flatbuffers::Parser().Parse(valid_schema.c_str(), include_directories));
+
+  flatbuffers::Parser p;
+  TEST_ASSERT(p.Parse(valid_schema.c_str(), include_directories));
+
+  // Load invalid 2 file Flatbuffer schema
+  const auto invalid_path =
+      flatbuffers::ConCatPathFileName(name_clash_path, "invalid_test1.fbs");
+  std::string invalid_schema;
+  TEST_ASSERT(
+      flatbuffers::LoadFile(invalid_path.c_str(), false, &invalid_schema));
+  // Clashing table and union names in same namespace must fail to parse
+  TEST_EQ(
+      flatbuffers::Parser().Parse(invalid_schema.c_str(), include_directories),
+      false);
+}
+
 void InvalidNestedFlatbufferTest() {
   // First, load and parse FlatBuffer schema (.fbs)
   std::string schemafile;
@@ -2792,6 +3035,34 @@
   TEST_EQ(parser2.Parse("{a_type:Bool,a:{b:true}}"), true);
 }
 
+void StructUnionTest() {
+  GadgetUnion gadget;
+  gadget.Set(FallingTub(100));
+
+  HandFanT fan;
+  fan.length = 10;
+  gadget.Set(fan);
+}
+
+void WarningsAsErrorsTest() {
+  {
+    flatbuffers::IDLOptions opts;
+    // opts.warnings_as_errors should default to false
+    flatbuffers::Parser parser(opts);
+    TEST_EQ(parser.Parse("table T { THIS_NAME_CAUSES_A_WARNING:string;}\n"
+                         "root_type T;"),
+            true);
+  }
+  {
+    flatbuffers::IDLOptions opts;
+    opts.warnings_as_errors = true;
+    flatbuffers::Parser parser(opts);
+    TEST_EQ(parser.Parse("table T { THIS_NAME_CAUSES_A_WARNING:string;}\n"
+                         "root_type T;"),
+            false);
+  }
+}
+
 void ConformTest() {
   flatbuffers::Parser parser;
   TEST_EQ(parser.Parse("table T { A:int; } enum E:byte { A }"), true);
@@ -2839,64 +3110,45 @@
   // Write the equivalent of:
   // { vec: [ -100, "Fred", 4.0, false ], bar: [ 1, 2, 3 ], bar3: [ 1, 2, 3 ],
   // foo: 100, bool: true, mymap: { foo: "Fred" } }
-  // clang-format off
-  #ifndef FLATBUFFERS_CPP98_STL
-    // It's possible to do this without std::function support as well.
-    slb.Map([&]() {
-       slb.Vector("vec", [&]() {
-        slb += -100;  // Equivalent to slb.Add(-100) or slb.Int(-100);
-        slb += "Fred";
-        slb.IndirectFloat(4.0f);
-        auto i_f = slb.LastValue();
-        uint8_t blob[] = { 77 };
-        slb.Blob(blob, 1);
-        slb += false;
-        slb.ReuseValue(i_f);
-      });
-      int ints[] = { 1, 2, 3 };
-      slb.Vector("bar", ints, 3);
-      slb.FixedTypedVector("bar3", ints, 3);
-      bool bools[] = {true, false, true, false};
-      slb.Vector("bools", bools, 4);
-      slb.Bool("bool", true);
-      slb.Double("foo", 100);
-      slb.Map("mymap", [&]() {
-        slb.String("foo", "Fred");  // Testing key and string reuse.
-      });
-    });
-    slb.Finish();
-  #else
-    // It's possible to do this without std::function support as well.
-    slb.Map([](flexbuffers::Builder& slb2) {
-       slb2.Vector("vec", [](flexbuffers::Builder& slb3) {
-        slb3 += -100;  // Equivalent to slb.Add(-100) or slb.Int(-100);
-        slb3 += "Fred";
-        slb3.IndirectFloat(4.0f);
-        auto i_f = slb3.LastValue();
-        uint8_t blob[] = { 77 };
-        slb3.Blob(blob, 1);
-        slb3 += false;
-        slb3.ReuseValue(i_f);
-      }, slb2);
-      int ints[] = { 1, 2, 3 };
-      slb2.Vector("bar", ints, 3);
-      slb2.FixedTypedVector("bar3", ints, 3);
-      slb2.Bool("bool", true);
-      slb2.Double("foo", 100);
-      slb2.Map("mymap", [](flexbuffers::Builder& slb3) {
-        slb3.String("foo", "Fred");  // Testing key and string reuse.
-      }, slb2);
-    }, slb);
-    slb.Finish();
-  #endif  // FLATBUFFERS_CPP98_STL
 
+  // It's possible to do this without std::function support as well.
+  slb.Map([&]() {
+    slb.Vector("vec", [&]() {
+      slb += -100;  // Equivalent to slb.Add(-100) or slb.Int(-100);
+      slb += "Fred";
+      slb.IndirectFloat(4.0f);
+      auto i_f = slb.LastValue();
+      uint8_t blob[] = { 77 };
+      slb.Blob(blob, 1);
+      slb += false;
+      slb.ReuseValue(i_f);
+    });
+    int ints[] = { 1, 2, 3 };
+    slb.Vector("bar", ints, 3);
+    slb.FixedTypedVector("bar3", ints, 3);
+    bool bools[] = { true, false, true, false };
+    slb.Vector("bools", bools, 4);
+    slb.Bool("bool", true);
+    slb.Double("foo", 100);
+    slb.Map("mymap", [&]() {
+      slb.String("foo", "Fred");  // Testing key and string reuse.
+    });
+  });
+  slb.Finish();
+
+// clang-format off
   #ifdef FLATBUFFERS_TEST_VERBOSE
     for (size_t i = 0; i < slb.GetBuffer().size(); i++)
-      printf("%d ", flatbuffers::vector_data(slb.GetBuffer())[i]);
+      printf("%d ", slb.GetBuffer().data()[i]);
     printf("\n");
   #endif
   // clang-format on
 
+  std::vector<uint8_t> reuse_tracker;
+  TEST_EQ(flexbuffers::VerifyBuffer(slb.GetBuffer().data(),
+                                    slb.GetBuffer().size(), &reuse_tracker),
+          true);
+
   auto map = flexbuffers::GetRoot(slb.GetBuffer()).AsMap();
   TEST_EQ(map.size(), 7);
   auto vec = map["vec"].AsVector();
@@ -2954,6 +3206,9 @@
   slb.Clear();
   auto jsontest = "{ a: [ 123, 456.0 ], b: \"hello\", c: true, d: false }";
   TEST_EQ(parser.ParseFlexBuffer(jsontest, nullptr, &slb), true);
+  TEST_EQ(flexbuffers::VerifyBuffer(slb.GetBuffer().data(),
+                                    slb.GetBuffer().size(), &reuse_tracker),
+          true);
   auto jroot = flexbuffers::GetRoot(slb.GetBuffer());
   auto jmap = jroot.AsMap();
   auto jvec = jmap["a"].AsVector();
@@ -2980,6 +3235,34 @@
   TEST_EQ(slb.GetSize(), 664);
 }
 
+void FlexBuffersFloatingPointTest() {
+#if defined(FLATBUFFERS_HAS_NEW_STRTOD) && (FLATBUFFERS_HAS_NEW_STRTOD > 0)
+  flexbuffers::Builder slb(512,
+                           flexbuffers::BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);
+  // Parse floating-point values from JSON:
+  flatbuffers::Parser parser;
+  slb.Clear();
+  auto jsontest =
+      "{ a: [1.0, nan, inf, infinity, -inf, +inf, -infinity, 8.0] }";
+  TEST_EQ(parser.ParseFlexBuffer(jsontest, nullptr, &slb), true);
+  auto jroot = flexbuffers::GetRoot(slb.GetBuffer());
+  TEST_EQ(flexbuffers::VerifyBuffer(slb.GetBuffer().data(),
+                                    slb.GetBuffer().size(), nullptr),
+          true);
+  auto jmap = jroot.AsMap();
+  auto jvec = jmap["a"].AsVector();
+  TEST_EQ(8, jvec.size());
+  TEST_EQ(1.0, jvec[0].AsDouble());
+  TEST_ASSERT(is_quiet_nan(jvec[1].AsDouble()));
+  TEST_EQ(infinity_d, jvec[2].AsDouble());
+  TEST_EQ(infinity_d, jvec[3].AsDouble());
+  TEST_EQ(-infinity_d, jvec[4].AsDouble());
+  TEST_EQ(+infinity_d, jvec[5].AsDouble());
+  TEST_EQ(-infinity_d, jvec[6].AsDouble());
+  TEST_EQ(8.0, jvec[7].AsDouble());
+#endif
+}
+
 void FlexBuffersDeprecatedTest() {
   // FlexBuffers as originally designed had a flaw involving the
   // FBT_VECTOR_STRING datatype, and this test documents/tests the fix for it.
@@ -3009,6 +3292,10 @@
   // same way, the fix lies on the reading side.
   slb.EndVector(start, true, false);
   slb.Finish();
+  // Verify because why not.
+  TEST_EQ(flexbuffers::VerifyBuffer(slb.GetBuffer().data(),
+                                    slb.GetBuffer().size(), nullptr),
+          true);
   // So now lets read this data back.
   // For existing data, since we have no way of knowing what the actual
   // bit-width of the size field of the string is, we are going to ignore this
@@ -3140,6 +3427,31 @@
   TEST_EQ(b == a, true);
   TEST_EQ(b != a, false);
 
+  a.enemy.reset(new MonsterT());
+  TEST_EQ(b != a, true);
+  a.enemy->mana = 33;
+  TEST_EQ(b == a, false);
+  TEST_EQ(b != a, true);
+
+  b.enemy.reset(new MonsterT());
+  TEST_EQ(b == a, false);
+  TEST_EQ(b != a, true);
+  b.enemy->mana = 33;
+  TEST_EQ(b == a, true);
+  TEST_EQ(b != a, false);
+
+  a.enemy.reset(nullptr);
+  TEST_EQ(b == a, false);
+  TEST_EQ(b != a, true);
+  b.enemy->mana = 150;
+  TEST_EQ(b == a, false);
+  TEST_EQ(b != a, true);
+  a.enemy.reset(new MonsterT());
+  TEST_EQ(b == a, true);
+  TEST_EQ(b != a, false);
+
+  b.enemy.reset(nullptr);
+
   b.test.type = Any_Monster;
   TEST_EQ(b == a, false);
   TEST_EQ(b != a, true);
@@ -3177,11 +3489,11 @@
   TEST_EQ(null_b1.o, null_b2.o);
 
   // Put the strings into an array for round trip verification.
-  const flatbuffers::Offset<flatbuffers::String> array[7] = {
+  std::array<flatbuffers::Offset<flatbuffers::String>, 7> array = {
     one1, two, one2, onetwo, null_b1, null_c, null_b2
   };
   const auto vector_offset =
-      builder.CreateVector(array, flatbuffers::uoffset_t(7));
+      builder.CreateVector<flatbuffers::Offset<flatbuffers::String>>(array);
   MonsterBuilder monster_builder(builder);
   monster_builder.add_name(two);
   monster_builder.add_testarrayofstring(vector_offset);
@@ -3297,9 +3609,9 @@
 void FlatbuffersSpanTest() {}
 #endif
 
-void FixedLengthArrayTest() {
-  // VS10 does not support typed enums, exclude from tests
+// VS10 does not support typed enums, exclude from tests
 #if !defined(_MSC_VER) || _MSC_VER >= 1700
+void FixedLengthArrayTest() {
   // Generate an ArrayTable containing one ArrayStruct.
   flatbuffers::FlatBufferBuilder fbb;
   MyGame::Example::NestedStruct nStruct0(MyGame::Example::TestEnum::B);
@@ -3333,10 +3645,10 @@
   aStruct.mutable_d()->Mutate(1, nStruct1);
   auto aTable = MyGame::Example::CreateArrayTable(fbb, &aStruct);
   MyGame::Example::FinishArrayTableBuffer(fbb, aTable);
-
   // Verify correctness of the ArrayTable.
   flatbuffers::Verifier verifier(fbb.GetBufferPointer(), fbb.GetSize());
-  MyGame::Example::VerifyArrayTableBuffer(verifier);
+  TEST_ASSERT(MyGame::Example::VerifyArrayTableBuffer(verifier));
+  // Do test.
   auto p = MyGame::Example::GetMutableArrayTable(fbb.GetBufferPointer());
   auto mArStruct = p->mutable_a();
   TEST_NOTNULL(mArStruct);
@@ -3346,10 +3658,10 @@
   TEST_NOTNULL(mArStruct->mutable_b());
   TEST_NOTNULL(mArStruct->mutable_d());
   TEST_NOTNULL(mArStruct->mutable_f());
-  mArStruct->mutable_b()->Mutate(14, -14);
   TEST_EQ(mArStruct->a(), 2);
   TEST_EQ(mArStruct->b()->size(), 15);
-  TEST_EQ(mArStruct->b()->Get(aStruct.b()->size() - 1), -14);
+  mArStruct->mutable_b()->Mutate(14, -14);
+  TEST_EQ(mArStruct->b()->Get(14), -14);
   TEST_EQ(mArStruct->c(), 12);
   TEST_NOTNULL(mArStruct->d()->Get(0));
   TEST_NOTNULL(mArStruct->d()->Get(0)->a());
@@ -3391,21 +3703,23 @@
   // set memory chunk of size ArrayStruct to 1's
   std::memset(static_cast<void *>(non_zero_memory), 1, arr_size);
   // after placement-new it should be all 0's
-#if defined (_MSC_VER) && defined (_DEBUG)
-  #undef new
-#endif
-  MyGame::Example::ArrayStruct *ap = new (non_zero_memory) MyGame::Example::ArrayStruct;
-#if defined (_MSC_VER) && defined (_DEBUG)
-  #define new DEBUG_NEW
-#endif
+#  if defined(_MSC_VER) && defined(_DEBUG)
+#    undef new
+#  endif
+  MyGame::Example::ArrayStruct *ap =
+      new (non_zero_memory) MyGame::Example::ArrayStruct;
+#  if defined(_MSC_VER) && defined(_DEBUG)
+#    define new DEBUG_NEW
+#  endif
   (void)ap;
-  for (size_t i = 0; i < arr_size; ++i) {
-    TEST_EQ(non_zero_memory[i], 0);
-  }
-#endif
+  for (size_t i = 0; i < arr_size; ++i) { TEST_EQ(non_zero_memory[i], 0); }
 }
+#else
+void FixedLengthArrayTest() {}
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1700
 
-#if !defined(FLATBUFFERS_SPAN_MINIMAL) && (!defined(_MSC_VER) || _MSC_VER >= 1700)
+#if !defined(FLATBUFFERS_SPAN_MINIMAL) && \
+    (!defined(_MSC_VER) || _MSC_VER >= 1700)
 void FixedLengthArrayConstructorTest() {
   const int32_t nested_a[2] = { 1, 2 };
   MyGame::Example::TestEnum nested_c[2] = { MyGame::Example::TestEnum::A,
@@ -3452,8 +3766,7 @@
   TEST_EQ(arr_struct.f()->Get(1), -1);
 }
 #else
-void FixedLengthArrayConstructorTest() {
-}
+void FixedLengthArrayConstructorTest() {}
 #endif
 
 void NativeTypeTest() {
@@ -3461,10 +3774,13 @@
 
   Geometry::ApplicationDataT src_data;
   src_data.vectors.reserve(N);
+  src_data.vectors_alt.reserve(N);
 
   for (int i = 0; i < N; ++i) {
     src_data.vectors.push_back(
         Native::Vector3D(10 * i + 0.1f, 10 * i + 0.2f, 10 * i + 0.3f));
+    src_data.vectors_alt.push_back(
+        Native::Vector3D(20 * i + 0.1f, 20 * i + 0.2f, 20 * i + 0.3f));
   }
 
   flatbuffers::FlatBufferBuilder fbb;
@@ -3473,16 +3789,21 @@
   auto dstDataT = Geometry::UnPackApplicationData(fbb.GetBufferPointer());
 
   for (int i = 0; i < N; ++i) {
-    Native::Vector3D &v = dstDataT->vectors[i];
+    const Native::Vector3D &v = dstDataT->vectors[i];
     TEST_EQ(v.x, 10 * i + 0.1f);
     TEST_EQ(v.y, 10 * i + 0.2f);
     TEST_EQ(v.z, 10 * i + 0.3f);
+
+    const Native::Vector3D &v2 = dstDataT->vectors_alt[i];
+    TEST_EQ(v2.x, 20 * i + 0.1f);
+    TEST_EQ(v2.y, 20 * i + 0.2f);
+    TEST_EQ(v2.z, 20 * i + 0.3f);
   }
 }
 
-void FixedLengthArrayJsonTest(bool binary) {
-  // VS10 does not support typed enums, exclude from tests
+// VS10 does not support typed enums, exclude from tests
 #if !defined(_MSC_VER) || _MSC_VER >= 1700
+void FixedLengthArrayJsonTest(bool binary) {
   // load FlatBuffer schema (.fbs) and JSON from disk
   std::string schemafile;
   std::string jsonfile;
@@ -3539,11 +3860,86 @@
                       parserGen.builder_.GetBufferPointer(),
                       parserOrg.builder_.GetSize()),
           0);
-#else
-  (void)binary;
-#endif
 }
 
+void FixedLengthArraySpanTest() {
+  // load FlatBuffer schema (.fbs) and JSON from disk
+  std::string schemafile;
+  std::string jsonfile;
+  TEST_EQ(flatbuffers::LoadFile((test_data_path + "arrays_test.fbs").c_str(),
+                                false, &schemafile),
+          true);
+  TEST_EQ(flatbuffers::LoadFile((test_data_path + "arrays_test.golden").c_str(),
+                                false, &jsonfile),
+          true);
+
+  // parse schema first, so we can use it to parse the data after
+  flatbuffers::Parser parser;
+  TEST_EQ(parser.Parse(schemafile.c_str()), true);
+  TEST_EQ(parser.Parse(jsonfile.c_str()), true);
+  auto &fbb = parser.builder_;
+  auto verifier = flatbuffers::Verifier(fbb.GetBufferPointer(), fbb.GetSize());
+  TEST_EQ(true, VerifyArrayTableBuffer(verifier));
+
+  auto p = MyGame::Example::GetMutableArrayTable(fbb.GetBufferPointer());
+  TEST_NOTNULL(p);
+  auto table_struct = p->mutable_a();
+  TEST_NOTNULL(table_struct);
+  TEST_EQ(2, table_struct->d()->size());
+  TEST_NOTNULL(table_struct->d());
+  TEST_NOTNULL(table_struct->mutable_d());
+  // test array of structs
+  auto const_d = flatbuffers::make_span(*table_struct->d());
+  auto mutable_d = flatbuffers::make_span(*table_struct->mutable_d());
+  TEST_EQ(2, const_d.size());
+  TEST_EQ(2, mutable_d.size());
+  TEST_ASSERT(const_d[0] == mutable_d[0]);
+  TEST_ASSERT(const_d[1] == mutable_d[1]);
+  mutable_d[0] = const_d[0];  // mutate
+  // test scalars
+  auto &const_nested = const_d[0];
+  auto &mutable_nested = mutable_d[0];
+  static_assert(sizeof(MyGame::Example::TestEnum) == sizeof(uint8_t),
+                "TestEnum's underlaying type must by byte");
+  TEST_NOTNULL(const_nested.d());
+  TEST_NOTNULL(mutable_nested.d());
+  {
+    flatbuffers::span<const MyGame::Example::TestEnum, 2> const_d_c =
+        flatbuffers::make_span(*const_nested.c());
+    auto mutable_d_c = flatbuffers::make_span(*mutable_nested.mutable_c());
+    TEST_EQ(2, const_d_c.size());
+    TEST_EQ(2, mutable_d_c.size());
+    TEST_EQ(MyGame::Example::TestEnum::C, const_d_c[0]);
+    TEST_EQ(MyGame::Example::TestEnum::B, const_d_c[1]);
+    TEST_ASSERT(mutable_d_c.end() == std::copy(const_d_c.cbegin(),
+                                               const_d_c.cend(),
+                                               mutable_d_c.begin()));
+    TEST_ASSERT(
+        std::equal(const_d_c.cbegin(), const_d_c.cend(), mutable_d_c.cbegin()));
+  }
+  // test little endian array of int32
+#  if FLATBUFFERS_LITTLEENDIAN
+  {
+    flatbuffers::span<const int32_t, 2> const_d_a =
+        flatbuffers::make_span(*const_nested.a());
+    auto mutable_d_a = flatbuffers::make_span(*mutable_nested.mutable_a());
+    TEST_EQ(2, const_d_a.size());
+    TEST_EQ(2, mutable_d_a.size());
+    TEST_EQ(-1, const_d_a[0]);
+    TEST_EQ(2, const_d_a[1]);
+    TEST_ASSERT(mutable_d_a.end() == std::copy(const_d_a.cbegin(),
+                                               const_d_a.cend(),
+                                               mutable_d_a.begin()));
+    TEST_ASSERT(
+        std::equal(const_d_a.cbegin(), const_d_a.cend(), mutable_d_a.cbegin()));
+  }
+#  endif
+}
+#else
+void FixedLengthArrayJsonTest(bool /*binary*/) {}
+void FixedLengthArraySpanTest() {}
+#endif
+
 void TestEmbeddedBinarySchema() {
   // load JSON from disk
   std::string jsonfile;
@@ -3592,6 +3988,24 @@
           0);
 }
 
+void StringVectorDefaultsTest() {
+  std::vector<std::string> schemas;
+  schemas.push_back("table Monster { mana: string = \"\"; }");
+  schemas.push_back("table Monster { mana: string = \"mystr\"; }");
+  schemas.push_back("table Monster { mana: string = \"  \"; }");
+  schemas.push_back("table Monster { mana: string = \"null\"; }");
+  schemas.push_back("table Monster { mana: [int] = []; }");
+  schemas.push_back("table Monster { mana: [uint] = [  ]; }");
+  schemas.push_back("table Monster { mana: [byte] = [\t\t\n]; }");
+  schemas.push_back("enum E:int{}table Monster{mana:[E]=[];}");
+  for (auto s = schemas.begin(); s < schemas.end(); s++) {
+    flatbuffers::Parser parser;
+    TEST_ASSERT(parser.Parse(s->c_str()));
+    const auto *mana = parser.structs_.Lookup("Monster")->fields.Lookup("mana");
+    TEST_EQ(mana->IsDefault(), true);
+  }
+}
+
 void OptionalScalarsTest() {
   // Simple schemas and a "has optional scalar" sentinal.
   std::vector<std::string> schemas;
@@ -3610,12 +4024,15 @@
   schemas.push_back("table Monster { mana : bool; }");
   schemas.push_back("table Monster { mana : bool = 42; }");
   schemas.push_back("table Monster { mana : bool = null; }");
-  schemas.push_back("enum Enum: int {A=0, B=1} "
-                    "table Monster { mana : Enum; }");
-  schemas.push_back("enum Enum: int {A=0, B=1} "
-                    "table Monster { mana : Enum = B; }");
-  schemas.push_back("enum Enum: int {A=0, B=1} "
-                    "table Monster { mana : Enum = null; }");
+  schemas.push_back(
+      "enum Enum: int {A=0, B=1} "
+      "table Monster { mana : Enum; }");
+  schemas.push_back(
+      "enum Enum: int {A=0, B=1} "
+      "table Monster { mana : Enum = B; }");
+  schemas.push_back(
+      "enum Enum: int {A=0, B=1} "
+      "table Monster { mana : Enum = null; }");
 
   // Check the FieldDef is correctly set.
   for (auto schema = schemas.begin(); schema < schemas.end(); schema++) {
@@ -3623,7 +4040,7 @@
     flatbuffers::Parser parser;
     TEST_ASSERT(parser.Parse(schema->c_str()));
     const auto *mana = parser.structs_.Lookup("Monster")->fields.Lookup("mana");
-    TEST_EQ(mana->optional, has_null);
+    TEST_EQ(mana->IsOptional(), has_null);
   }
 
   // Test if nullable scalars are allowed for each language.
@@ -3710,6 +4127,115 @@
   }
 }
 
+void FieldIdentifierTest() {
+  using flatbuffers::Parser;
+  TEST_EQ(true, Parser().Parse("table T{ f: int (id:0); }"));
+  // non-integer `id` should be rejected
+  TEST_EQ(false, Parser().Parse("table T{ f: int (id:text); }"));
+  TEST_EQ(false, Parser().Parse("table T{ f: int (id:\"text\"); }"));
+  TEST_EQ(false, Parser().Parse("table T{ f: int (id:0text); }"));
+  TEST_EQ(false, Parser().Parse("table T{ f: int (id:1.0); }"));
+  TEST_EQ(false, Parser().Parse("table T{ f: int (id:-1); g: int (id:0); }"));
+  TEST_EQ(false, Parser().Parse("table T{ f: int (id:129496726); }"));
+  // A unuion filed occupys two ids: enumerator + pointer (offset).
+  TEST_EQ(false,
+          Parser().Parse("union X{} table T{ u: X(id:0); table F{x:int;\n}"));
+  // Positive tests for unions
+  TEST_EQ(true, Parser().Parse("union X{} table T{ u: X (id:1); }"));
+  TEST_EQ(true, Parser().Parse("union X{} table T{ u: X; }"));
+  // Test using 'inf' and 'nan' words both as identifiers and as default values.
+  TEST_EQ(true, Parser().Parse("table T{ nan: string; }"));
+  TEST_EQ(true, Parser().Parse("table T{ inf: string; }"));
+#if defined(FLATBUFFERS_HAS_NEW_STRTOD) && (FLATBUFFERS_HAS_NEW_STRTOD > 0)
+  TEST_EQ(true, Parser().Parse("table T{ inf: float = inf; }"));
+  TEST_EQ(true, Parser().Parse("table T{ nan: float = inf; }"));
+#endif
+}
+
+void ParseIncorrectMonsterJsonTest() {
+  std::string schemafile;
+  TEST_EQ(flatbuffers::LoadFile((test_data_path + "monster_test.bfbs").c_str(),
+                                true, &schemafile),
+          true);
+  flatbuffers::Parser parser;
+  flatbuffers::Verifier verifier(
+      reinterpret_cast<const uint8_t *>(schemafile.c_str()), schemafile.size());
+  TEST_EQ(reflection::VerifySchemaBuffer(verifier), true);
+  TEST_EQ(parser.Deserialize((const uint8_t *)schemafile.c_str(),
+                             schemafile.size()),
+          true);
+  TEST_EQ(parser.ParseJson("{name:\"monster\"}"), true);
+  TEST_EQ(parser.ParseJson(""), false);
+  TEST_EQ(parser.ParseJson("{name: 1}"), false);
+  TEST_EQ(parser.ParseJson("{name:+1}"), false);
+  TEST_EQ(parser.ParseJson("{name:-1}"), false);
+  TEST_EQ(parser.ParseJson("{name:-f}"), false);
+  TEST_EQ(parser.ParseJson("{name:+f}"), false);
+}
+
+#if !defined(_MSC_VER) || _MSC_VER >= 1700
+template<class T, class Container>
+void TestIterators(const std::vector<T> &expected, const Container &tested) {
+  TEST_ASSERT(tested.rbegin().base() == tested.end());
+  TEST_ASSERT(tested.crbegin().base() == tested.cend());
+  TEST_ASSERT(tested.rend().base() == tested.begin());
+  TEST_ASSERT(tested.crend().base() == tested.cbegin());
+
+  size_t k = 0;
+  for (auto it = tested.begin(); it != tested.end(); ++it, ++k) {
+    const auto &e = expected.at(k);
+    TEST_EQ(*it, e);
+  }
+  TEST_EQ(k, expected.size());
+
+  k = expected.size();
+  for (auto it = tested.rbegin(); it != tested.rend(); ++it, --k) {
+    const auto &e = expected.at(k - 1);
+    TEST_EQ(*it, e);
+  }
+  TEST_EQ(k, 0);
+}
+
+void FlatbuffersIteratorsTest() {
+  {
+    flatbuffers::FlatBufferBuilder fbb;
+    const std::vector<unsigned char> inv_data = { 1, 2, 3 };
+    {
+      auto mon_name = fbb.CreateString("MyMonster");  // key, mandatory
+      auto inv_vec = fbb.CreateVector(inv_data);
+      auto empty_i64_vec =
+          fbb.CreateVector(static_cast<const int64_t *>(nullptr), 0);
+      MonsterBuilder mb(fbb);
+      mb.add_name(mon_name);
+      mb.add_inventory(inv_vec);
+      mb.add_vector_of_longs(empty_i64_vec);
+      FinishMonsterBuffer(fbb, mb.Finish());
+    }
+    const auto &mon = *flatbuffers::GetRoot<Monster>(fbb.GetBufferPointer());
+
+    TEST_EQ_STR("MyMonster", mon.name()->c_str());
+    TEST_ASSERT(mon.inventory());
+    TEST_ASSERT(mon.vector_of_longs());
+    TestIterators(inv_data, *mon.inventory());
+    TestIterators(std::vector<int64_t>(), *mon.vector_of_longs());
+  }
+
+  {
+    flatbuffers::FlatBufferBuilder fbb;
+    MyGame::Example::ArrayStruct aStruct;
+    MyGame::Example::FinishArrayTableBuffer(
+        fbb, MyGame::Example::CreateArrayTable(fbb, &aStruct));
+    const auto &array_table =
+        *flatbuffers::GetRoot<ArrayTable>(fbb.GetBufferPointer());
+    TEST_ASSERT(array_table.a());
+    auto &int_15 = *array_table.a()->b();
+    TestIterators(std::vector<int>(15, 0), int_15);
+  }
+}
+#else
+void FlatbuffersIteratorsTest() {}
+#endif
+
 int FlatBufferTests() {
   // clang-format off
 
@@ -3717,11 +4243,7 @@
 
   std::string rawbuf;
   auto flatbuf1 = CreateFlatBufferTest(rawbuf);
-  #if !defined(FLATBUFFERS_CPP98_STL)
-    auto flatbuf = std::move(flatbuf1);  // Test move assignment.
-  #else
-    auto &flatbuf = flatbuf1;
-  #endif // !defined(FLATBUFFERS_CPP98_STL)
+  auto flatbuf = std::move(flatbuf1);  // Test move assignment.
 
   TriviallyCopyableTest();
 
@@ -3760,6 +4282,8 @@
   #endif
   // clang-format on
 
+  UtilConvertCase();
+
   FuzzTest1();
   FuzzTest2();
 
@@ -3779,6 +4303,8 @@
   InvalidUTF8Test();
   UnknownFieldsTest();
   ParseUnionTest();
+  ValidSameNameDifferentNamespaceTest();
+  MultiFileNameClashTest();
   InvalidNestedFlatbufferTest();
   ConformTest();
   ParseProtoBufAsciiTest();
@@ -3802,10 +4328,32 @@
   ParseFlexbuffersFromJsonWithNullTest();
   FlatbuffersSpanTest();
   FixedLengthArrayConstructorTest();
+  FieldIdentifierTest();
+  StringVectorDefaultsTest();
+  ParseIncorrectMonsterJsonTest();
+  FlexBuffersFloatingPointTest();
+  FlatbuffersIteratorsTest();
+  FixedLengthArraySpanTest();
+  StructUnionTest();
+  WarningsAsErrorsTest();
   return 0;
 }
 
-int main(int /*argc*/, const char * /*argv*/[]) {
+int main(int argc, const char *argv[]) {
+  for (int argi = 1; argi < argc; argi++) {
+    std::string arg = argv[argi];
+    if (arg == "--test_path") {
+      if (++argi >= argc) {
+        fprintf(stderr, "error: missing path following: %s\n", arg.c_str());
+        exit(1);
+      }
+      test_data_path = argv[argi];
+    } else {
+      fprintf(stderr, "error: Unknown argument: %s\n", arg.c_str());
+      exit(1);
+    }
+  }
+
   InitTestEngine();
 
   std::string req_locale;