diff --git a/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs b/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs
index b09119c..b4093d4 100644
--- a/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs
+++ b/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs
@@ -16,7 +16,9 @@
 
 using System.IO;
 using System.Text;
+using System.Threading;
 using MyGame.Example;
+using optional_scalars;
 
 namespace FlatBuffers.Test
 {
@@ -111,18 +113,18 @@
             }
 
             // Dump to output directory so we can inspect later, if needed
-#if ENABLE_SPAN_T
+            #if ENABLE_SPAN_T
             var data = fbb.DataBuffer.ToSizedArray();
-            string filename = @"Resources/monsterdata_cstest" + (sizePrefix ? "_sp" : "") + ".mon";
+            string filename = @".tmp/monsterdata_cstest" + (sizePrefix ? "_sp" : "") + ".mon";
             File.WriteAllBytes(filename, data);
-#else
+            #else
             using (var ms = fbb.DataBuffer.ToMemoryStream(fbb.DataBuffer.Position, fbb.Offset))
             {
                 var data = ms.ToArray();
-                string filename = @"Resources/monsterdata_cstest" + (sizePrefix ? "_sp" : "") + ".mon";
+                string filename = @".tmp/monsterdata_cstest" + (sizePrefix ? "_sp" : "") + ".mon";
                 File.WriteAllBytes(filename, data);
             }
-#endif
+            #endif
 
             // Remove the size prefix if necessary for further testing
             ByteBuffer dataBuffer = fbb.DataBuffer;
@@ -156,11 +158,7 @@
             Assert.IsTrue(monster.TestarrayoftablesByKey("Barney") != null);
             Assert.IsTrue(monster.TestarrayoftablesByKey("Wilma") != null);
 
-            // testType is an existing field and mutating it should succeed
-            Assert.AreEqual(monster.TestType, Any.Monster);
-            Assert.AreEqual(monster.MutateTestType(Any.NONE), true);
-            Assert.AreEqual(monster.TestType, Any.NONE);
-            Assert.AreEqual(monster.MutateTestType(Any.Monster), true);
+            // testType is an existing field
             Assert.AreEqual(monster.TestType, Any.Monster);
 
             //mutate the inventory vector
@@ -191,6 +189,7 @@
             Assert.AreEqual(pos.X, 1.0f);
 
             TestBuffer(dataBuffer);
+            TestObjectAPI(Monster.GetRootAsMonster(dataBuffer));
         }
 
         private void TestBuffer(ByteBuffer bb)
@@ -248,7 +247,7 @@
 
             Assert.AreEqual(true, monster.Testbool);
 
-#if ENABLE_SPAN_T
+            #if ENABLE_SPAN_T
             var nameBytes = monster.GetNameBytes();
             Assert.AreEqual("MyMonster", Encoding.UTF8.GetString(nameBytes.ToArray(), 0, nameBytes.Length));
 
@@ -260,7 +259,13 @@
             {
                 Assert.IsTrue(monster.GetTestarrayofboolsBytes().Length != 0);
             }
-#else
+
+            var longArrayBytes = monster.GetVectorOfLongsBytes();
+            Assert.IsTrue(monster.VectorOfLongsLength * 8 == longArrayBytes.Length);
+
+            var doubleArrayBytes = monster.GetVectorOfDoublesBytes();
+            Assert.IsTrue(monster.VectorOfDoublesLength * 8 == doubleArrayBytes.Length);
+            #else
             var nameBytes = monster.GetNameBytes().Value;
             Assert.AreEqual("MyMonster", Encoding.UTF8.GetString(nameBytes.Array, nameBytes.Offset, nameBytes.Count));
 
@@ -272,15 +277,26 @@
             {
                 Assert.IsTrue(monster.GetTestarrayofboolsBytes().HasValue);
             }
-#endif
+            #endif
         }
 
         [FlatBuffersTestMethod]
         public void CanReadCppGeneratedWireFile()
         {
-            var data = File.ReadAllBytes(@"Resources/monsterdata_test.mon");
+            var data = File.ReadAllBytes(@"../monsterdata_test.mon");
             var bb = new ByteBuffer(data);
             TestBuffer(bb);
+            TestObjectAPI(Monster.GetRootAsMonster(bb));
+        }
+
+        [FlatBuffersTestMethod]
+        public void CanReadJsonFile()
+        {
+            var jsonText = File.ReadAllText(@"../monsterdata_test.json");
+            var mon = MonsterT.DeserializeFromJson(jsonText);
+            var fbb = new FlatBufferBuilder(1);
+            fbb.Finish(Monster.Pack(fbb, mon).Value);
+            TestBuffer(fbb.DataBuffer);
         }
 
         [FlatBuffersTestMethod]
@@ -293,6 +309,27 @@
         }
 
         [FlatBuffersTestMethod]
+        public void TestVectorOfEnums()
+        {
+            const string monsterName = "TestVectorOfEnumsMonster";
+            var colorVec = new Color[] { Color.Red, Color.Green, Color.Blue };
+            var fbb = new FlatBufferBuilder(32);
+            var str1 = fbb.CreateString(monsterName);
+            var vec1 = Monster.CreateVectorOfEnumsVector(fbb, colorVec);
+            Monster.StartMonster(fbb);
+            Monster.AddName(fbb, str1);
+            Monster.AddVectorOfEnums(fbb, vec1);
+            var monster1 = Monster.EndMonster(fbb);
+            Monster.FinishMonsterBuffer(fbb, monster1);
+
+            var mons = Monster.GetRootAsMonster(fbb.DataBuffer);
+            var colors = mons.GetVectorOfEnumsArray();
+            Assert.ArrayEqual(colorVec, colors);
+
+            TestObjectAPI(mons);
+        }
+
+        [FlatBuffersTestMethod]
         public void TestNestedFlatBuffer()
         {
             const string nestedMonsterName = "NestedMonsterName";
@@ -329,6 +366,9 @@
             Assert.AreEqual(nestedMonsterMana, nestedMonster.Mana);
             Assert.AreEqual(nestedMonsterHp, nestedMonster.Hp);
             Assert.AreEqual(nestedMonsterName, nestedMonster.Name);
+
+            TestObjectAPI(mons);
+            TestObjectAPI(nestedMonster);
         }
 
         [FlatBuffersTestMethod]
@@ -342,6 +382,9 @@
             int[,]  d_a = new int[2, 2];
             TestEnum[]  d_b = new TestEnum[2];
             TestEnum[,] d_c = new TestEnum[2, 2];
+            long[,]     d_d = new long[2, 2];
+            int         e;
+            long[]      f = new long[2];
 
             a = 0.5f;
             for (int i = 0; i < 15; i++) b[i] = i;
@@ -356,9 +399,16 @@
             d_c[0, 1] = TestEnum.B;
             d_c[1, 0] = TestEnum.C;
             d_c[1, 1] = TestEnum.B;
+            d_d[0, 0] = -1;
+            d_d[0, 1] = 1;
+            d_d[1, 0] = -2;
+            d_d[1, 1] = 2;
+            e = 2;
+            f[0] = -1;
+            f[1] = 1;
 
             Offset<ArrayStruct> arrayOffset = ArrayStruct.CreateArrayStruct(
-                builder, a, b, c, d_a, d_b, d_c);
+                builder, a, b, c, d_a, d_b, d_c, d_d, e, f);
 
             // Create a table with the ArrayStruct.
             ArrayTable.StartArrayTable(builder);
@@ -369,19 +419,683 @@
 
             ArrayTable table = ArrayTable.GetRootAsArrayTable(builder.DataBuffer);
 
-            Assert.AreEqual(table.A?.A, 0.5f);
-            for (int i = 0; i < 15; i++) Assert.AreEqual(table.A?.B(i), i);
-            Assert.AreEqual(table.A?.C, (sbyte)1);
-            Assert.AreEqual(table.A?.D(0).A(0), 1);
-            Assert.AreEqual(table.A?.D(0).A(1), 2);
-            Assert.AreEqual(table.A?.D(1).A(0), 3);
-            Assert.AreEqual(table.A?.D(1).A(1), 4);
-            Assert.AreEqual(table.A?.D(0).B, TestEnum.B);
-            Assert.AreEqual(table.A?.D(1).B, TestEnum.C);
-            Assert.AreEqual(table.A?.D(0).C(0), TestEnum.A);
-            Assert.AreEqual(table.A?.D(0).C(1), TestEnum.B);
-            Assert.AreEqual(table.A?.D(1).C(0), TestEnum.C);
-            Assert.AreEqual(table.A?.D(1).C(1), TestEnum.B);
+            Assert.AreEqual(table.A.Value.A, 0.5f);
+            for (int i = 0; i < 15; i++) Assert.AreEqual(table.A.Value.B(i), i);
+            Assert.AreEqual(table.A.Value.C, (sbyte)1);
+            Assert.AreEqual(table.A.Value.D(0).A(0), 1);
+            Assert.AreEqual(table.A.Value.D(0).A(1), 2);
+            Assert.AreEqual(table.A.Value.D(1).A(0), 3);
+            Assert.AreEqual(table.A.Value.D(1).A(1), 4);
+            Assert.AreEqual(table.A.Value.D(0).B, TestEnum.B);
+            Assert.AreEqual(table.A.Value.D(1).B, TestEnum.C);
+            Assert.AreEqual(table.A.Value.D(0).C(0), TestEnum.A);
+            Assert.AreEqual(table.A.Value.D(0).C(1), TestEnum.B);
+            Assert.AreEqual(table.A.Value.D(1).C(0), TestEnum.C);
+            Assert.AreEqual(table.A.Value.D(1).C(1), TestEnum.B);
+            Assert.AreEqual(table.A.Value.D(0).D(0), -1);
+            Assert.AreEqual(table.A.Value.D(0).D(1), 1);
+            Assert.AreEqual(table.A.Value.D(1).D(0), -2);
+            Assert.AreEqual(table.A.Value.D(1).D(1), 2);
+            Assert.AreEqual(table.A.Value.E, 2);
+            Assert.AreEqual(table.A.Value.F(0), -1);
+            Assert.AreEqual(table.A.Value.F(1), 1);
+
+            TestObjectAPI(table);
+        }
+
+        [FlatBuffersTestMethod]
+        public void TestUnionVector()
+        {
+            var fbb = new FlatBufferBuilder(100);
+            var rapunzel = Rapunzel.CreateRapunzel(fbb, 40).Value;
+
+            var characterTypes = new[]
+            {
+                Character.MuLan,
+                Character.Belle,
+                Character.Other,
+            };
+            var characterTypesOffset = Movie.CreateCharactersTypeVector(fbb, characterTypes);
+
+            var characters = new[]
+            {
+                Attacker.CreateAttacker(fbb, 10).Value,
+                BookReader.CreateBookReader(fbb, 20).Value,
+                fbb.CreateSharedString("Chip").Value,
+            };
+            var charactersOffset = Movie.CreateCharactersVector(fbb, characters);
+
+            var movieOffset = Movie.CreateMovie(
+                fbb,
+                Character.Rapunzel,
+                rapunzel,
+                characterTypesOffset,
+                charactersOffset);
+            Movie.FinishMovieBuffer(fbb, movieOffset);
+
+            var movie = Movie.GetRootAsMovie(fbb.DataBuffer);
+            Assert.AreEqual(Character.Rapunzel, movie.MainCharacterType);
+            Assert.AreEqual(40, movie.MainCharacter<Rapunzel>().Value.HairLength);
+
+            Assert.AreEqual(3, movie.CharactersLength);
+            Assert.AreEqual(Character.MuLan, movie.CharactersType(0));
+            Assert.AreEqual(10, movie.Characters<Attacker>(0).Value.SwordAttackDamage);
+            Assert.AreEqual(Character.Belle, movie.CharactersType(1));
+            Assert.AreEqual(20, movie.Characters<BookReader>(1).Value.BooksRead);
+            Assert.AreEqual(Character.Other, movie.CharactersType(2));
+            Assert.AreEqual("Chip", movie.CharactersAsString(2));
+
+            TestObjectAPI(movie);
+        }
+
+        private void AreEqual(Monster a, MonsterT b)
+        {
+            Assert.AreEqual(a.Hp, b.Hp);
+            Assert.AreEqual(a.Mana, b.Mana);
+            Assert.AreEqual(a.Name, b.Name);
+
+            var posA = a.Pos;
+            var posB = b.Pos;
+            if (posA != null)
+            {
+                Assert.AreEqual(posA.Value.X, posB.X);
+                Assert.AreEqual(posA.Value.Y, posB.Y);
+                Assert.AreEqual(posA.Value.Z, posB.Z);
+
+                Assert.AreEqual(posA.Value.Test1, posB.Test1);
+                Assert.AreEqual(posA.Value.Test2, posB.Test2);
+                var tA = posA.Value.Test3;
+                var tB = posB.Test3;
+                Assert.AreEqual(tA.A, tB.A);
+                Assert.AreEqual(tA.B, tB.B);
+            }
+
+            Assert.AreEqual(a.TestType, b.Test.Type);
+            if (a.TestType == Any.Monster)
+            {
+                var monster2A = a.Test<Monster>().Value;
+                var monster2B = b.Test.AsMonster();
+                Assert.AreEqual(monster2A.Name, monster2B.Name);
+            }
+
+            Assert.AreEqual(a.InventoryLength, b.Inventory.Count);
+            for (var i = 0; i < a.InventoryLength; ++i)
+            {
+                Assert.AreEqual(a.Inventory(i), b.Inventory[i]);
+            }
+
+            var inventoryArray = a.GetInventoryArray();
+            var inventoryArrayLength = inventoryArray == null ? 0 : inventoryArray.Length;
+            Assert.AreEqual(inventoryArrayLength, b.Inventory.Count);
+            for (var i = 0; i < inventoryArrayLength; ++i)
+            {
+                Assert.AreEqual(inventoryArray[i], b.Inventory[i]);
+            }
+
+            Assert.AreEqual(a.Test4Length, b.Test4.Count);
+            for (var i = 0; i < a.Test4Length; ++i)
+            {
+                var t4A = a.Test4(i);
+                var t4B = b.Test4[i];
+                Assert.AreEqual(t4A.Value.A, t4B.A);
+                Assert.AreEqual(t4A.Value.B, t4B.B);
+            }
+
+            Assert.AreEqual(a.TestarrayofstringLength, b.Testarrayofstring.Count);
+            for (var i = 0; i < a.TestarrayofstringLength; ++i)
+            {
+                Assert.AreEqual(a.Testarrayofstring(i), b.Testarrayofstring[i]);
+            }
+
+            Assert.AreEqual(a.Testbool, b.Testbool);
+
+            Assert.AreEqual(a.TestarrayofboolsLength, b.Testarrayofbools.Count);
+            for (var i = 0; i < a.TestarrayofboolsLength; ++i)
+            {
+                Assert.AreEqual(a.Testarrayofbools(i), b.Testarrayofbools[i]);
+            }
+
+            Assert.AreEqual(a.VectorOfLongsLength, b.VectorOfLongs.Count);
+            for (var i = 0; i < a.VectorOfLongsLength; ++i)
+            {
+                Assert.AreEqual(a.VectorOfLongs(i), b.VectorOfLongs[i]);
+            }
+
+            Assert.AreEqual(a.VectorOfDoublesLength, b.VectorOfDoubles.Count);
+            for (var i = 0; i < a.VectorOfDoublesLength; ++i)
+            {
+                Assert.AreEqual(a.VectorOfDoubles(i), b.VectorOfDoubles[i]);
+            }
+
+            Assert.AreEqual(a.VectorOfEnumsLength, b.VectorOfEnums.Count);
+            for (var i = 0; i < a.VectorOfEnumsLength; ++i)
+            {
+                Assert.AreEqual(a.VectorOfEnums(i), b.VectorOfEnums[i]);
+            }
+        }
+
+        private void AreEqual(Monster a, Monster b)
+        {
+            Assert.AreEqual(a.Hp, b.Hp);
+            Assert.AreEqual(a.Mana, b.Mana);
+            Assert.AreEqual(a.Name, b.Name);
+
+            var posA = a.Pos;
+            var posB = b.Pos;
+            if (posA != null)
+            {
+                Assert.AreEqual(posA.Value.X, posB.Value.X);
+                Assert.AreEqual(posA.Value.Y, posB.Value.Y);
+                Assert.AreEqual(posA.Value.Z, posB.Value.Z);
+
+                Assert.AreEqual(posA.Value.Test1, posB.Value.Test1);
+                Assert.AreEqual(posA.Value.Test2, posB.Value.Test2);
+                var tA = posA.Value.Test3;
+                var tB = posB.Value.Test3;
+                Assert.AreEqual(tA.A, tB.A);
+                Assert.AreEqual(tA.B, tB.B);
+            }
+
+            Assert.AreEqual(a.TestType, b.TestType);
+            if (a.TestType == Any.Monster)
+            {
+                var monster2A = a.Test<Monster>().Value;
+                var monster2B = b.Test<Monster>().Value;
+                Assert.AreEqual(monster2A.Name, monster2B.Name);
+            }
+
+            Assert.AreEqual(a.InventoryLength, b.InventoryLength);
+            for (var i = 0; i < a.InventoryLength; ++i)
+            {
+                Assert.AreEqual(a.Inventory(i), b.Inventory(i));
+            }
+
+            var inventoryArrayA = a.GetInventoryArray();
+            var inventoryArrayALength = inventoryArrayA == null ? 0 : inventoryArrayA.Length;
+            var inventoryArrayB = b.GetInventoryArray();
+            var inventoryArrayBLength = inventoryArrayB == null ? 0 : inventoryArrayB.Length;
+            Assert.AreEqual(inventoryArrayALength, inventoryArrayBLength);
+            for (var i = 0; i < inventoryArrayALength; ++i)
+            {
+                Assert.AreEqual(inventoryArrayA[i], inventoryArrayB[i]);
+            }
+
+            Assert.AreEqual(a.Test4Length, b.Test4Length);
+            for (var i = 0; i < a.Test4Length; ++i)
+            {
+                var t4A = a.Test4(i);
+                var t4B = b.Test4(i);
+                Assert.AreEqual(t4A.Value.A, t4B.Value.A);
+                Assert.AreEqual(t4A.Value.B, t4B.Value.B);
+            }
+
+            Assert.AreEqual(a.TestarrayofstringLength, b.TestarrayofstringLength);
+            for (var i = 0; i < a.TestarrayofstringLength; ++i)
+            {
+                Assert.AreEqual(a.Testarrayofstring(i), b.Testarrayofstring(i));
+            }
+
+            Assert.AreEqual(a.Testbool, b.Testbool);
+
+            Assert.AreEqual(a.TestarrayofboolsLength, b.TestarrayofboolsLength);
+            for (var i = 0; i < a.TestarrayofboolsLength; ++i)
+            {
+                Assert.AreEqual(a.Testarrayofbools(i), b.Testarrayofbools(i));
+            }
+
+            Assert.AreEqual(a.VectorOfLongsLength, b.VectorOfLongsLength);
+            for (var i = 0; i < a.VectorOfLongsLength; ++i)
+            {
+                Assert.AreEqual(a.VectorOfLongs(i), b.VectorOfLongs(i));
+            }
+
+            Assert.AreEqual(a.VectorOfDoublesLength, b.VectorOfDoublesLength);
+            for (var i = 0; i < a.VectorOfDoublesLength; ++i)
+            {
+                Assert.AreEqual(a.VectorOfDoubles(i), b.VectorOfDoubles(i));
+            }
+
+            Assert.AreEqual(a.VectorOfEnumsLength, b.VectorOfEnumsLength);
+            for (var i = 0; i < a.VectorOfEnumsLength; ++i)
+            {
+                Assert.AreEqual(a.VectorOfEnums(i), b.VectorOfEnums(i));
+            }
+        }
+
+        private void TestObjectAPI(Monster a)
+        {
+            var b = a.UnPack();
+            AreEqual(a, b);
+
+            var fbb = new FlatBufferBuilder(1);
+            fbb.Finish(Monster.Pack(fbb, b).Value);
+            var c = Monster.GetRootAsMonster(fbb.DataBuffer);
+            AreEqual(a, c);
+
+            var jsonText = b.SerializeToJson();
+            var d = MonsterT.DeserializeFromJson(jsonText);
+            AreEqual(a, d);
+
+            var fbBuffer = b.SerializeToBinary();
+            Assert.IsTrue(Monster.MonsterBufferHasIdentifier(new ByteBuffer(fbBuffer)));
+            var e = MonsterT.DeserializeFromBinary(fbBuffer);
+            AreEqual(a, e);
+        }
+
+        private void AreEqual(ArrayTable a, ArrayTableT b)
+        {
+            Assert.AreEqual(a.A.Value.A, b.A.A);
+
+            for (int i = 0; i < 15; ++i)
+            {
+                Assert.AreEqual(a.A.Value.B(i), b.A.B[i]);
+            }
+
+            Assert.AreEqual(a.A.Value.C, b.A.C);
+
+            for (int i = 0; i < 2; ++i)
+            {
+                var ad = a.A.Value.D(i);
+                var bd = b.A.D[i];
+
+                for (int j = 0; j < 2; ++j)
+                {
+                    Assert.AreEqual(ad.A(j), bd.A[j]);
+                }
+
+                Assert.AreEqual(ad.B, bd.B);
+
+                for (int j = 0; j < 2; ++j)
+                {
+                    Assert.AreEqual(ad.C(j), bd.C[j]);
+                }
+
+                for (int j = 0; j < 2; ++j)
+                {
+                    Assert.AreEqual(ad.D(j), bd.D[j]);
+                }
+            }
+
+            Assert.AreEqual(a.A.Value.E, b.A.E);
+
+            for (int i = 0; i < 2; ++i)
+            {
+                Assert.AreEqual(a.A.Value.F(i), b.A.F[i]);
+            }
+        }
+
+        private void AreEqual(ArrayTable a, ArrayTable b)
+        {
+            Assert.AreEqual(a.A.Value.A, b.A.Value.A);
+
+            for (int i = 0; i < 15; ++i)
+            {
+                Assert.AreEqual(a.A.Value.B(i), b.A.Value.B(i));
+            }
+
+            Assert.AreEqual(a.A.Value.C, b.A.Value.C);
+
+            for (int i = 0; i < 2; ++i)
+            {
+                var ad = a.A.Value.D(i);
+                var bd = b.A.Value.D(i);
+
+                for (int j = 0; j < 2; ++j)
+                {
+                    Assert.AreEqual(ad.A(j), bd.A(j));
+                }
+
+                Assert.AreEqual(ad.B, bd.B);
+
+                for (int j = 0; j < 2; ++j)
+                {
+                    Assert.AreEqual(ad.C(j), bd.C(j));
+                }
+
+                for (int j = 0; j < 2; ++j)
+                {
+                    Assert.AreEqual(ad.D(j), bd.D(j));
+                }
+            }
+
+            Assert.AreEqual(a.A.Value.E, b.A.Value.E);
+
+            for (int i = 0; i < 2; ++i)
+            {
+                Assert.AreEqual(a.A.Value.F(i), b.A.Value.F(i));
+            }
+        }
+
+        private void TestObjectAPI(ArrayTable a)
+        {
+            var b = a.UnPack();
+            AreEqual(a, b);
+
+            var fbb = new FlatBufferBuilder(1);
+            fbb.Finish(ArrayTable.Pack(fbb, b).Value);
+            var c = ArrayTable.GetRootAsArrayTable(fbb.DataBuffer);
+            AreEqual(a, c);
+
+            var jsonText = b.SerializeToJson();
+            var d = ArrayTableT.DeserializeFromJson(jsonText);
+            AreEqual(a, d);
+
+            var fbBuffer = b.SerializeToBinary();
+            Assert.IsTrue(ArrayTable.ArrayTableBufferHasIdentifier(new ByteBuffer(fbBuffer)));
+            var e = ArrayTableT.DeserializeFromBinary(fbBuffer);
+            AreEqual(a, e);
+        }
+
+        private void AreEqual(Movie a, MovieT b)
+        {
+            Assert.AreEqual(a.MainCharacterType, b.MainCharacter.Type);
+            Assert.AreEqual(a.MainCharacter<Rapunzel>().Value.HairLength, b.MainCharacter.AsRapunzel().HairLength);
+
+            Assert.AreEqual(a.CharactersLength, b.Characters.Count);
+            Assert.AreEqual(a.CharactersType(0), b.Characters[0].Type);
+            Assert.AreEqual(a.Characters<Attacker>(0).Value.SwordAttackDamage, b.Characters[0].AsMuLan().SwordAttackDamage);
+            Assert.AreEqual(a.CharactersType(1), b.Characters[1].Type);
+            Assert.AreEqual(a.Characters<BookReader>(1).Value.BooksRead, b.Characters[1].AsBelle().BooksRead);
+            Assert.AreEqual(a.CharactersType(2), b.Characters[2].Type);
+            Assert.AreEqual(a.CharactersAsString(2), b.Characters[2].AsOther());
+        }
+
+        private void AreEqual(Movie a, Movie b)
+        {
+            Assert.AreEqual(a.MainCharacterType, b.MainCharacterType);
+            Assert.AreEqual(a.MainCharacter<Rapunzel>().Value.HairLength, b.MainCharacter<Rapunzel>().Value.HairLength);
+
+            Assert.AreEqual(a.CharactersLength, b.CharactersLength);
+            Assert.AreEqual(a.CharactersType(0), b.CharactersType(0));
+            Assert.AreEqual(a.Characters<Attacker>(0).Value.SwordAttackDamage, b.Characters<Attacker>(0).Value.SwordAttackDamage);
+            Assert.AreEqual(a.CharactersType(1), b.CharactersType(1));
+            Assert.AreEqual(a.Characters<BookReader>(1).Value.BooksRead, b.Characters<BookReader>(1).Value.BooksRead);
+            Assert.AreEqual(a.CharactersType(2), b.CharactersType(2));
+            Assert.AreEqual(a.CharactersAsString(2), b.CharactersAsString(2));
+        }
+
+        private void TestObjectAPI(Movie a)
+        {
+            var b = a.UnPack();
+            AreEqual(a, b);
+
+            var fbb = new FlatBufferBuilder(1);
+            fbb.Finish(Movie.Pack(fbb, b).Value);
+            var c = Movie.GetRootAsMovie(fbb.DataBuffer);
+            AreEqual(a, c);
+
+            var jsonText = b.SerializeToJson();
+            var d = MovieT.DeserializeFromJson(jsonText);
+            AreEqual(a, d);
+
+            var fbBuffer = b.SerializeToBinary();
+            Assert.IsTrue(Movie.MovieBufferHasIdentifier(new ByteBuffer(fbBuffer)));
+            var e = MovieT.DeserializeFromBinary(fbBuffer);
+            AreEqual(a, e);
+        }
+
+        // For use in TestParallelAccess test case.
+        static private int _comparisons = 0;
+        static private int _failures = 0;
+        static private void KeepComparing(Monster mon, int count, float floatValue, double doubleValue)
+        {
+            int i = 0;
+            while (++i <= count)
+            {
+                Interlocked.Add(ref _comparisons, 1);
+                if(mon.Pos.Value.Test1 != doubleValue || mon.Pos.Value.Z != floatValue) {
+                    Interlocked.Add(ref _failures, 1);
+                }
+            }
+        }
+
+        [FlatBuffersTestMethod]
+        public void TestParallelAccess() {
+            // Tests that reading from a flatbuffer over multiple threads is thread-safe in regard to double and float
+            // values, since they previously were non-thread safe
+            const float floatValue = 3.141592F;
+            const double doubleValue = 1.618033988;
+
+            var fbb = new FlatBufferBuilder(1);
+            var str = fbb.CreateString("ParallelTest");
+            Monster.StartMonster(fbb);
+            Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, floatValue, doubleValue,
+                                                     Color.Green, (short)5, (sbyte)6));
+
+            Monster.AddName(fbb, str);
+            Monster.FinishMonsterBuffer(fbb, Monster.EndMonster(fbb));
+
+            var mon = Monster.GetRootAsMonster(fbb.DataBuffer);
+
+            var pos = mon.Pos.Value;
+            Assert.AreEqual(pos.Test1, doubleValue);
+            Assert.AreEqual(pos.Z, floatValue);
+
+            const int thread_count = 10;
+            const int reps = 1000000;
+
+            // Need to use raw Threads since Tasks are not supported in .NET 3.5
+            Thread[] threads = new Thread[thread_count];
+            for(int i = 0; i < thread_count; i++) {
+               threads[i] = new Thread(() => KeepComparing(mon, reps, floatValue, doubleValue));
+            }
+            for(int i = 0; i < thread_count; i++) {
+               threads[i].Start();
+            }
+            for(int i = 0; i < thread_count; i++) {
+               threads[i].Join();
+            }
+
+            // Make sure the threads actually did the comparisons.
+            Assert.AreEqual(thread_count * reps, _comparisons);
+
+            // Make sure we never read the values incorrectly.
+            Assert.AreEqual(0, _failures);
+        }
+
+        [FlatBuffersTestMethod]
+        public void TestScalarOptional_EmptyBuffer() {
+            var fbb = new FlatBufferBuilder(1);
+            ScalarStuff.StartScalarStuff(fbb);
+            var offset = ScalarStuff.EndScalarStuff(fbb);
+            ScalarStuff.FinishScalarStuffBuffer(fbb, offset);
+
+            ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer);
+            Assert.AreEqual((sbyte)0, scalarStuff.JustI8);
+            Assert.AreEqual(null, scalarStuff.MaybeI8);
+            Assert.AreEqual((sbyte)42, scalarStuff.DefaultI8);
+            Assert.AreEqual((byte)0, scalarStuff.JustU8);
+            Assert.AreEqual(null, scalarStuff.MaybeU8);
+            Assert.AreEqual((byte)42, scalarStuff.DefaultU8);
+
+            Assert.AreEqual((short)0, scalarStuff.JustI16);
+            Assert.AreEqual(null, scalarStuff.MaybeI16);
+            Assert.AreEqual((short)42, scalarStuff.DefaultI16);
+            Assert.AreEqual((ushort)0, scalarStuff.JustU16);
+            Assert.AreEqual(null, scalarStuff.MaybeU16);
+            Assert.AreEqual((ushort)42, scalarStuff.DefaultU16);
+
+            Assert.AreEqual((int)0, scalarStuff.JustI32);
+            Assert.AreEqual(null, scalarStuff.MaybeI32);
+            Assert.AreEqual((int)42, scalarStuff.DefaultI32);
+            Assert.AreEqual((uint)0, scalarStuff.JustU32);
+            Assert.AreEqual(null, scalarStuff.MaybeU32);
+            Assert.AreEqual((uint)42, scalarStuff.DefaultU32);
+
+            Assert.AreEqual((long)0, scalarStuff.JustI64);
+            Assert.AreEqual(null, scalarStuff.MaybeI64);
+            Assert.AreEqual((long)42, scalarStuff.DefaultI64);
+            Assert.AreEqual((ulong)0, scalarStuff.JustU64);
+            Assert.AreEqual(null, scalarStuff.MaybeU64);
+            Assert.AreEqual((ulong)42, scalarStuff.DefaultU64);
+
+            Assert.AreEqual((float)0.0F, scalarStuff.JustF32);
+            Assert.AreEqual(null, scalarStuff.MaybeF32);
+            Assert.AreEqual((float)42.0F, scalarStuff.DefaultF32);
+
+            Assert.AreEqual((double)0.0, scalarStuff.JustF64);
+            Assert.AreEqual(null, scalarStuff.MaybeF64);
+            Assert.AreEqual((double)42.0, scalarStuff.DefaultF64);
+
+            Assert.AreEqual(false, scalarStuff.JustBool);
+            Assert.AreEqual(null, scalarStuff.MaybeBool);
+            Assert.AreEqual(true, scalarStuff.DefaultBool);
+
+            Assert.AreEqual(OptionalByte.None, scalarStuff.JustEnum);
+            Assert.AreEqual(null, scalarStuff.MaybeEnum);
+            Assert.AreEqual(OptionalByte.One, scalarStuff.DefaultEnum);
+        }
+
+        [FlatBuffersTestMethod]
+        public void TestScalarOptional_Construction() {
+            var fbb = new FlatBufferBuilder(1);
+            ScalarStuff.StartScalarStuff(fbb);
+            ScalarStuff.AddJustI8(fbb, 5);
+            ScalarStuff.AddMaybeI8(fbb, 5);
+            ScalarStuff.AddDefaultI8(fbb, 5);
+            ScalarStuff.AddJustU8(fbb, 6);
+            ScalarStuff.AddMaybeU8(fbb, 6);
+            ScalarStuff.AddDefaultU8(fbb, 6);
+
+            ScalarStuff.AddJustI16(fbb, 7);
+            ScalarStuff.AddMaybeI16(fbb, 7);
+            ScalarStuff.AddDefaultI16(fbb, 7);
+            ScalarStuff.AddJustU16(fbb, 8);
+            ScalarStuff.AddMaybeU16(fbb, 8);
+            ScalarStuff.AddDefaultU16(fbb, 8);
+
+            ScalarStuff.AddJustI32(fbb, 9);
+            ScalarStuff.AddMaybeI32(fbb, 9);
+            ScalarStuff.AddDefaultI32(fbb, 9);
+            ScalarStuff.AddJustU32(fbb, 10);
+            ScalarStuff.AddMaybeU32(fbb, 10);
+            ScalarStuff.AddDefaultU32(fbb, 10);
+
+            ScalarStuff.AddJustI64(fbb, 11);
+            ScalarStuff.AddMaybeI64(fbb, 11);
+            ScalarStuff.AddDefaultI64(fbb, 11);
+            ScalarStuff.AddJustU64(fbb, 12);
+            ScalarStuff.AddMaybeU64(fbb, 12);
+            ScalarStuff.AddDefaultU64(fbb, 12);
+
+            ScalarStuff.AddJustF32(fbb, 13.0f);
+            ScalarStuff.AddMaybeF32(fbb, 13.0f);
+            ScalarStuff.AddDefaultF32(fbb, 13.0f);
+            ScalarStuff.AddJustF64(fbb, 14.0);
+            ScalarStuff.AddMaybeF64(fbb, 14.0);
+            ScalarStuff.AddDefaultF64(fbb, 14.0);
+
+            ScalarStuff.AddJustBool(fbb, true);
+            ScalarStuff.AddMaybeBool(fbb, true);
+            ScalarStuff.AddDefaultBool(fbb, false); // note this is the opposite
+
+            ScalarStuff.AddJustEnum(fbb, OptionalByte.Two);
+            ScalarStuff.AddMaybeEnum(fbb, OptionalByte.Two);
+            ScalarStuff.AddDefaultEnum(fbb, OptionalByte.Two);
+
+            var offset = ScalarStuff.EndScalarStuff(fbb);
+            ScalarStuff.FinishScalarStuffBuffer(fbb, offset);
+
+            ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer);
+            Assert.AreEqual((sbyte)5, scalarStuff.JustI8);
+            Assert.AreEqual((sbyte)5, scalarStuff.MaybeI8);
+            Assert.AreEqual((sbyte)5, scalarStuff.DefaultI8);
+            Assert.AreEqual((byte)6, scalarStuff.JustU8);
+            Assert.AreEqual((byte)6, scalarStuff.MaybeU8);
+            Assert.AreEqual((byte)6, scalarStuff.DefaultU8);
+
+            Assert.AreEqual((short)7, scalarStuff.JustI16);
+            Assert.AreEqual((short)7, scalarStuff.MaybeI16);
+            Assert.AreEqual((short)7, scalarStuff.DefaultI16);
+            Assert.AreEqual((ushort)8, scalarStuff.JustU16);
+            Assert.AreEqual((ushort)8, scalarStuff.MaybeU16);
+            Assert.AreEqual((ushort)8, scalarStuff.DefaultU16);
+
+            Assert.AreEqual((int)9, scalarStuff.JustI32);
+            Assert.AreEqual((int)9, scalarStuff.MaybeI32);
+            Assert.AreEqual((int)9, scalarStuff.DefaultI32);
+            Assert.AreEqual((uint)10, scalarStuff.JustU32);
+            Assert.AreEqual((uint)10, scalarStuff.MaybeU32);
+            Assert.AreEqual((uint)10, scalarStuff.DefaultU32);
+
+            Assert.AreEqual((long)11, scalarStuff.JustI64);
+            Assert.AreEqual((long)11, scalarStuff.MaybeI64);
+            Assert.AreEqual((long)11, scalarStuff.DefaultI64);
+            Assert.AreEqual((ulong)12, scalarStuff.JustU64);
+            Assert.AreEqual((ulong)12, scalarStuff.MaybeU64);
+            Assert.AreEqual((ulong)12, scalarStuff.DefaultU64);
+
+            Assert.AreEqual((float)13.0F, scalarStuff.JustF32);
+            Assert.AreEqual((float)13.0F, scalarStuff.MaybeF32);
+            Assert.AreEqual((float)13.0F, scalarStuff.DefaultF32);
+
+            Assert.AreEqual((double)14.0, scalarStuff.JustF64);
+            Assert.AreEqual((double)14.0, scalarStuff.MaybeF64);
+            Assert.AreEqual((double)14.0, scalarStuff.DefaultF64);
+
+            Assert.AreEqual(true, scalarStuff.JustBool);
+            Assert.AreEqual(true, scalarStuff.MaybeBool);
+            Assert.AreEqual(false, scalarStuff.DefaultBool);
+
+            Assert.AreEqual(OptionalByte.Two, scalarStuff.JustEnum);
+            Assert.AreEqual(OptionalByte.Two, scalarStuff.MaybeEnum);
+            Assert.AreEqual(OptionalByte.Two, scalarStuff.DefaultEnum);
+        }
+
+        [FlatBuffersTestMethod]
+        public void TestScalarOptional_Construction_CreatorMethod() {
+            var fbb = new FlatBufferBuilder(1);
+
+            var offset = ScalarStuff.CreateScalarStuff(fbb,5,5,5,6,6,6,7,7,7,
+                8,8,8,9,9,9,10,10,10,11,11,11,12,12,12,13.0f,13.0f,13.0f,14.0,
+                14.0,14.0,true,true,false,OptionalByte.Two,OptionalByte.Two,
+                OptionalByte.Two);
+            ScalarStuff.FinishScalarStuffBuffer(fbb, offset);
+
+            ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer);
+            Assert.AreEqual((sbyte)5, scalarStuff.JustI8);
+            Assert.AreEqual((sbyte)5, scalarStuff.MaybeI8);
+            Assert.AreEqual((sbyte)5, scalarStuff.DefaultI8);
+            Assert.AreEqual((byte)6, scalarStuff.JustU8);
+            Assert.AreEqual((byte)6, scalarStuff.MaybeU8);
+            Assert.AreEqual((byte)6, scalarStuff.DefaultU8);
+
+            Assert.AreEqual((short)7, scalarStuff.JustI16);
+            Assert.AreEqual((short)7, scalarStuff.MaybeI16);
+            Assert.AreEqual((short)7, scalarStuff.DefaultI16);
+            Assert.AreEqual((ushort)8, scalarStuff.JustU16);
+            Assert.AreEqual((ushort)8, scalarStuff.MaybeU16);
+            Assert.AreEqual((ushort)8, scalarStuff.DefaultU16);
+
+            Assert.AreEqual((int)9, scalarStuff.JustI32);
+            Assert.AreEqual((int)9, scalarStuff.MaybeI32);
+            Assert.AreEqual((int)9, scalarStuff.DefaultI32);
+            Assert.AreEqual((uint)10, scalarStuff.JustU32);
+            Assert.AreEqual((uint)10, scalarStuff.MaybeU32);
+            Assert.AreEqual((uint)10, scalarStuff.DefaultU32);
+
+            Assert.AreEqual((long)11, scalarStuff.JustI64);
+            Assert.AreEqual((long)11, scalarStuff.MaybeI64);
+            Assert.AreEqual((long)11, scalarStuff.DefaultI64);
+            Assert.AreEqual((ulong)12, scalarStuff.JustU64);
+            Assert.AreEqual((ulong)12, scalarStuff.MaybeU64);
+            Assert.AreEqual((ulong)12, scalarStuff.DefaultU64);
+
+            Assert.AreEqual((float)13.0F, scalarStuff.JustF32);
+            Assert.AreEqual((float)13.0F, scalarStuff.MaybeF32);
+            Assert.AreEqual((float)13.0F, scalarStuff.DefaultF32);
+
+            Assert.AreEqual((double)14.0, scalarStuff.JustF64);
+            Assert.AreEqual((double)14.0, scalarStuff.MaybeF64);
+            Assert.AreEqual((double)14.0, scalarStuff.DefaultF64);
+
+            Assert.AreEqual(true, scalarStuff.JustBool);
+            Assert.AreEqual(true, scalarStuff.MaybeBool);
+            Assert.AreEqual(false, scalarStuff.DefaultBool);
+
+            Assert.AreEqual(OptionalByte.Two, scalarStuff.JustEnum);
+            Assert.AreEqual(OptionalByte.Two, scalarStuff.MaybeEnum);
+            Assert.AreEqual(OptionalByte.Two, scalarStuff.DefaultEnum);
         }
     }
 }