/*
 * Copyright 2015 Google Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using Google.FlatBuffers;

namespace Google.FlatBuffers.Test
{
    [FlatBuffersTestClass]
    public class FlatBuffersFuzzTests
    {
        private readonly Lcg _lcg = new Lcg();

        [FlatBuffersTestMethod]
        public void TestObjects()
        {
            CheckObjects(11, 100);
        }

        [FlatBuffersTestMethod]
        public void TestNumbers()
        {
            var builder = new FlatBufferBuilder(1);
            Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
            builder.AddBool(true);
            Assert.ArrayEqual(new byte[] { 1 }, builder.DataBuffer.ToFullArray());
            builder.AddSbyte(-127);
            Assert.ArrayEqual(new byte[] { 129, 1 }, builder.DataBuffer.ToFullArray());
            builder.AddByte(255);
            Assert.ArrayEqual(new byte[] { 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // First pad
            builder.AddShort(-32222);
            Assert.ArrayEqual(new byte[] { 0, 0, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // Second pad
            builder.AddUshort(0xFEEE);
            Assert.ArrayEqual(new byte[] { 0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // no pad
            builder.AddInt(-53687092);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 204, 204, 204, 252, 0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // third pad
            builder.AddUint(0x98765432);
            Assert.ArrayEqual(new byte[] { 0x32, 0x54, 0x76, 0x98, 204, 204, 204, 252, 0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // no pad
        }

        [FlatBuffersTestMethod]
        public void TestNumbers64()
        {
            var builder = new FlatBufferBuilder(1);
            builder.AddUlong(0x1122334455667788);
            Assert.ArrayEqual(new byte[] { 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 }, builder.DataBuffer.ToFullArray());

            builder = new FlatBufferBuilder(1);
            builder.AddLong(0x1122334455667788);
            Assert.ArrayEqual(new byte[] { 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 }, builder.DataBuffer.ToFullArray());
        }

        [FlatBuffersTestMethod]
        public void TestVector_1xUInt8()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartVector(sizeof(byte), 1, 1);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.ToFullArray());
            builder.AddByte(1);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.ToFullArray());
            builder.EndVector();
            Assert.ArrayEqual(new byte[] { 1, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.ToFullArray());
        }

        [FlatBuffersTestMethod]
        public void TestVector_2xUint8()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartVector(sizeof(byte), 2, 1);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.ToFullArray());
            builder.AddByte(1);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, builder.DataBuffer.ToFullArray());
            builder.AddByte(2);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 2, 1, 0, 0 }, builder.DataBuffer.ToFullArray());
            builder.EndVector();
            Assert.ArrayEqual(new byte[] { 2, 0, 0, 0, 2, 1, 0, 0 }, builder.DataBuffer.ToFullArray());
        }

        [FlatBuffersTestMethod]
        public void TestVector_1xUInt16()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartVector(sizeof(ushort), 1, 1);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.ToFullArray());
            builder.AddUshort(1);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.ToFullArray());
            builder.EndVector();
            Assert.ArrayEqual(new byte[] { 1, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.ToFullArray());
        }

        [FlatBuffersTestMethod]
        public void TestVector_2xUInt16()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartVector(sizeof(ushort), 2, 1);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.ToFullArray());
            builder.AddUshort(0xABCD);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0xCD, 0xAB }, builder.DataBuffer.ToFullArray());
            builder.AddUshort(0xDCBA);
            Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0xBA, 0xDC, 0xCD, 0xAB }, builder.DataBuffer.ToFullArray());
            builder.EndVector();
            Assert.ArrayEqual(new byte[] { 2, 0, 0, 0, 0xBA, 0xDC, 0xCD, 0xAB }, builder.DataBuffer.ToFullArray());
        }

        [FlatBuffersTestMethod]
        public void TestCreateAsciiString()
        {
            var builder = new FlatBufferBuilder(1);
            builder.CreateString("foo");
            Assert.ArrayEqual(new byte[] { 3, 0, 0, 0, (byte)'f', (byte)'o', (byte)'o', 0 }, builder.DataBuffer.ToFullArray());

            builder.CreateString("moop");
            Assert.ArrayEqual(new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,  // Padding to 32 bytes
                4, 0, 0, 0,
                (byte)'m', (byte)'o', (byte)'o', (byte)'p',
                0, 0, 0, 0, // zero terminator with 3 byte pad
                3, 0, 0, 0,
                (byte)'f', (byte)'o', (byte)'o', 0
            }, builder.DataBuffer.ToFullArray());
        }

        [FlatBuffersTestMethod]
        public void TestCreateSharedAsciiString()
        {
            var builder = new FlatBufferBuilder(1);
            builder.CreateSharedString("foo");
            Assert.ArrayEqual(new byte[] { 3, 0, 0, 0, (byte)'f', (byte)'o', (byte)'o', 0 }, builder.DataBuffer.ToFullArray());

            builder.CreateSharedString("foo");
            Assert.ArrayEqual(new byte[] { 3, 0, 0, 0, (byte)'f', (byte)'o', (byte)'o', 0 }, builder.DataBuffer.ToFullArray());
        }

        [FlatBuffersTestMethod]
        public void TestCreateArbitarytring()
        {
            var builder = new FlatBufferBuilder(1);
            builder.CreateString("\x01\x02\x03");
            Assert.ArrayEqual(new byte[]
            {
                3, 0, 0, 0,
                0x01, 0x02, 0x03, 0
            }, builder.DataBuffer.ToFullArray()); // No padding
            builder.CreateString("\x04\x05\x06\x07");
            Assert.ArrayEqual(new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,  // Padding to 32 bytes
                4, 0, 0, 0,
                0x04, 0x05, 0x06, 0x07,
                0, 0, 0, 0, // zero terminator with 3 byte pad
                3, 0, 0, 0,
                0x01, 0x02, 0x03, 0
            }, builder.DataBuffer.ToFullArray()); // No padding
        }

        [FlatBuffersTestMethod]
        public void TestEmptyVTable()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(0);
            Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
            builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                4, 0, 4, 0,
                4, 0, 0, 0
            },
                builder.DataBuffer.ToFullArray());
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithOneBool()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(1);
            Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
            builder.AddBool(0, true, false);
            builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                0, 0, // padding to 16 bytes
                6, 0, // vtable bytes
                8, 0, // object length inc vtable offset
                7, 0, // start of bool value
                6, 0, 0, 0, // int32 offset for start of vtable
                0, 0, 0, // padding
                1, // value 0
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            var offset = 8;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
            // First field must be bool
            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 1, 1, true));
            // Check Error: Second field
            Assert.IsFalse(verifier.VerifyField((uint)offset, 6, 1, 1, true));
            // Check Error: First field too big alignment
            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 1, 2, true));
            // Check Error: First size to big
            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 1, true));
    }

    [FlatBuffersTestMethod]
        public void TestVTableWithOneBool_DefaultValue()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(1);
            Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
            builder.AddBool(0, false, false);
            builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                // No padding.
                4, 0, // vtable bytes
                4, 0, // end of object from here
                // entry 0 is not stored (trimmed end of vtable)
                4, 0, 0, 0, // int32 offset for start of vtable
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            var offset = 4;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
            // First field must be bool
            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 1, 1, false));
            // Error Check: First field not present
            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 1, 1, true));
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithOneInt16()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(1);
            Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
            builder.AddShort(0, 0x789A, 0);
            int offset = builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                0, 0, // padding to 16 bytes
                6, 0, // vtable bytes
                8, 0, // object length inc vtable offset
                6, 0, // start of int16 value
                6, 0, 0, 0, // int32 offset for start of vtable
                0, 0, // padding
                0x9A, 0x78, //value 0
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            offset += builder.DataBuffer.Position;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
            // First field must be ushort
            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 2, 2, true));
            // Check Error: Second field
            Assert.IsFalse(verifier.VerifyField((uint)offset, 6, 2, 2, true));
            // Check Error: First field too big alignment
            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 4, 2, true));
            // Check Error: First field size to big
            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 4, true));
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithTwoInt16()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(2);
            Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
            builder.AddShort(0, 0x3456, 0);
            builder.AddShort(1, 0x789A, 0);
            int offset = builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                8, 0, // vtable bytes
                8, 0, // object length inc vtable offset
                6, 0, // start of int16 value 0
                4, 0, // start of int16 value 1
                8, 0, 0, 0, // int32 offset for start of vtable
                0x9A, 0x78, // value 1
                0x56, 0x34, // value 0
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            offset += builder.DataBuffer.Position;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
            // First field must be ushort
            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 2, 2, true));
            // Check Error: Second field
            Assert.IsTrue(verifier.VerifyField((uint)offset, 6, 2, 2, true));
            // Check Error: Second field too big alignment
            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 4, 2, true));
            // Check Error: Second field size to big
            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 4, true));
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithInt16AndBool()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(2);
            Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
            builder.AddShort(0, 0x3456, 0);
            builder.AddBool(1, true, false);
            int offset = builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                8, 0, // vtable bytes
                8, 0, // object length inc vtable offset
                6, 0, // start of int16 value 0
                5, 0, // start of bool value 1
                8, 0, 0, 0, // int32 offset for start of vtable
                0, 1, // padding + value 1
                0x56, 0x34, // value 0
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            offset += builder.DataBuffer.Position;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
            // First field must be ushort
            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 2, 2, true));
            // Check Error: Second field must be bool
            Assert.IsTrue(verifier.VerifyField((uint)offset, 6, 1, 1, true));
            // Check Error: Second field too big alignment
            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 4, 2, true));
            // Check Error: Second field size to big
            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 4, true));
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithEmptyVector()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartVector(sizeof(byte), 0, 1);
            var vecEnd = builder.EndVector();

            builder.StartTable(1);

            builder.AddOffset(0, vecEnd.Value, 0);
            builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0,       // Padding to 32 bytes
                6, 0, // vtable bytes
                8, 0, // object length inc vtable offset
                4, 0, // start of vector offset value 0
                6, 0, 0, 0, // int32 offset for start of vtable
                4, 0, 0, 0,
                0, 0, 0, 0,
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = 20;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First field must be vector with element size 1
            Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 4, 1, true));
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithEmptyVectorAndScalars()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartVector(sizeof(byte), 0, 1);
            var vecEnd = builder.EndVector();

            builder.StartTable(2);
            builder.AddShort(0, 55, 0);
            builder.AddOffset(1, vecEnd.Value, 0);
            builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0, // Padding to 32 bytes
                8, 0, // vtable bytes
                12, 0, // object length inc vtable offset
                10, 0,     // offset to int16 value 0
                4, 0, // start of vector offset value 1
                8, 0, 0, 0, // int32 offset for start of vtable
                8, 0, 0, 0, // value 1
                0, 0, 55, 0, // value 0
                0, 0, 0, 0, // length of vector (not in sctruc)
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = 16;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First field must be short
            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 2, 2, true));
            // Second field must be vector with element size 1
            Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 6, 2, true));
       }


        [FlatBuffersTestMethod]
        public void TestVTableWith_1xInt16_and_Vector_or_2xInt16()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartVector(sizeof(short), 2, 1);
            builder.AddShort(0x1234);
            builder.AddShort(0x5678);
            var vecEnd = builder.EndVector();

            builder.StartTable(2);
            builder.AddOffset(1, vecEnd.Value, 0);
            builder.AddShort(0, 55, 0);
            builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                0, 0, 0, 0, // Padding to 32 bytes
                8, 0, // vtable bytes
                12, 0, // object length
                6, 0,     // start of value 0 from end of vtable
                8, 0,     // start of value 1 from end of buffer
                8, 0, 0, 0, // int32 offset for start of vtable
                0, 0, 55, 0,    // padding + value 0
                4, 0, 0, 0, // position of vector from here
                2, 0, 0, 0, // length of vector
                0x78, 0x56,       // vector value 0
                0x34, 0x12,       // vector value 1
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = 12;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // Second field must be vector with element size 2
            Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 6, 2, true));
            // Check Error: Second field with too big size
            Assert.IsFalse(verifier.VerifyVectorOfData(checkOffset, 6, 4, true));
            // First field must be short
            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 2, 2, true));
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithAStruct_of_int8_int16_int32()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(1);
            builder.Prep(4+4+4, 0);
            builder.AddSbyte(55);
            builder.Pad(3);
            builder.AddShort(0x1234);
            builder.Pad(2);
            builder.AddInt(0x12345678);
            var structStart = builder.Offset;
            builder.AddStruct(0, structStart, 0);
            builder.EndTable();
            Assert.ArrayEqual(new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, // Padding to 32 bytes
                6, 0, // vtable bytes
                16, 0, // object length
                4, 0,     // start of struct from here
                6, 0, 0, 0, // int32 offset for start of vtable
                0x78, 0x56, 0x34, 0x12,  // struct value 2
                0x00, 0x00, 0x34, 0x12, // struct value 1
                0x00, 0x00, 0x00, 55, // struct value 0
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = 16;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First field must be a struct with 12 bytes
            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 12, 4, true));
            // Check Error: First field with more than 12 bytes
            Assert.IsFalse(verifier.VerifyField(checkOffset, 4, 16, 4, true));
        }


        [FlatBuffersTestMethod]
        public void TestVTableWithAVectorOf_2xStructOf_2xInt8()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartVector(sizeof(byte)*2, 2, 1);
            builder.AddByte(33);
            builder.AddByte(44);
            builder.AddByte(55);
            builder.AddByte(66);
            var vecEnd = builder.EndVector();

            builder.StartTable(1);
            builder.AddOffset(0, vecEnd.Value, 0);
            builder.EndTable();

            Assert.ArrayEqual(new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, // Padding to 32 bytes
                6, 0, // vtable bytes
                8, 0, // object length
                4, 0,     // offset of vector offset
                6, 0, 0, 0, // int32 offset for start of vtable
                4, 0, 0, 0, // Vector start offset
                2, 0, 0, 0, // Vector len
                66, // vector 1, 1
                55, // vector 1, 0
                44, // vector 0, 1
                33, // vector 0, 0
            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = 16;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First field must be vector with element size 2
            Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 4, 2, true));
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithSomeElements()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(2);
            builder.AddByte(0, 33, 0);
            builder.AddShort(1, 66, 0);
            var off = builder.EndTable();
            builder.Finish(off);

            byte[] padded = new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0, //Padding to 32 bytes
                12, 0, 0, 0,     // root of table, pointing to vtable offset
                8, 0, // vtable bytes
                8, 0, // object length
                7, 0, // start of value 0
                4, 0, // start of value 1
                8, 0, 0, 0, // int32 offset for start of vtable
                66, 0, // value 1
                0, 33, // value 0

            };
            Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray());

            // no padding in sized array
            byte[] unpadded = new byte[padded.Length - 12];
            Buffer.BlockCopy(padded, 12, unpadded, 0, unpadded.Length);
            Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray());

            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First field must be a struct with 12 bytes
            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 1, 1, true));
            // Second field must be a struct with 12 bytes
            Assert.IsTrue(verifier.VerifyField(checkOffset, 6, 2, 2, true));
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithStrings()
        {
            var builder = new FlatBufferBuilder(64);
            var str1 = builder.CreateString("foo");
            var str2 = builder.CreateString("foobar");
            builder.StartTable(2);
            builder.AddOffset(0, str1.Value, 0);
            builder.AddOffset(1, str2.Value, 0);
            var off = builder.EndTable();
            builder.Finish(off);

            byte[] padded = new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0, //Padding to 32 bytes
                12, 0, 0, 0, // root of table, pointing to vtable offset
                8, 0, // vtable bytes
                12, 0, // object length
                8, 0, // start of value 0
                4, 0, // start of value 1
                8, 0, 0, 0, // int32 offset for start of vtable
                8, 0, 0, 0, // pointer to string
                16, 0, 0, 0, // pointer to string
                6, 0, 0, 0, // length of string
                102, 111, 111, 98, 97, 114, 0, 0, // "foobar" + padding
                3, 0, 0, 0, // length of string
                102, 111, 111, 0 // "bar"
            };
            Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray());

            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First field string check
            Assert.IsTrue(verifier.VerifyString(checkOffset, 4, true));
            // Second field string check
            Assert.IsTrue(verifier.VerifyString(checkOffset, 6, true));
        }

        [FlatBuffersTestMethod]
        public void TestVTableWithVectorOfStrings()
        {
            var builder = new FlatBufferBuilder(64);
            var str1 = builder.CreateString("foo");
            var str2 = builder.CreateString("foobar");
            builder.StartVector(sizeof(int), 2, 1);
            builder.AddOffset(str1.Value);
            builder.AddOffset(str2.Value);
            var vec = builder.EndVector();
            builder.StartTable(1);
            builder.AddOffset(0, vec.Value, 0);
            var off = builder.EndTable();
            builder.Finish(off);

            byte[] padded = new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0, //Padding to 32 bytes
                12, 0, 0, 0, // root of table, pointing to vtable offset
                0, 0, // padding
                6, 0, // vtable bytes
                8, 0, // object length
                4, 0, // start of value 0
                6, 0, 0, 0, // int32 offset for start of vtable
                4, 0, 0, 0, // pointer to vector
                2, 0, 0, 0, // length of vector
                8, 0, 0, 0, // int32 offset to string 1
                16, 0, 0, 0, // int32 offset to string 2
                6, 0, 0, 0, // length of string
                102, 111, 111, 98, 97, 114, 0, 0, // "foobar" + padding
                3, 0, 0, 0, // length of string
                102, 111, 111, 0 // "bar"
            };
            Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray());

            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First field string check
            Assert.IsTrue(verifier.VerifyVectorOfStrings(checkOffset, 4, true));
        }

        [FlatBuffersTestMethod]
        public void TestTwoFinishTable()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(2);
            builder.AddByte(0, 33, 0);
            builder.AddByte(1, 44, 0);
            var off0 = builder.EndTable();
            builder.Finish(off0);

            builder.StartTable(3);
            builder.AddByte(0, 55, 0);
            builder.AddByte(1, 66, 0);
            builder.AddByte(2, 77, 0);
            var off1 = builder.EndTable();
            builder.Finish(off1);

            Assert.ArrayEqual(new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,       // padding to 64 bytes
                16, 0, 0, 0,     // root of table, pointing to vtable offset (obj1)
                0, 0, // padding

                10, 0, // vtable bytes
                8, 0, // object length
                7, 0, // start of value 0
                6, 0, // start of value 1
                5, 0, // start of value 2
                10, 0, 0, 0, // int32 offset for start of vtable
                0, // pad
                77, // values 2, 1, 0
                66,
                55,

                12, 0, 0, 0,     // root of table, pointing to vtable offset (obj0)
                8, 0, // vtable bytes
                8, 0, // object length
                7, 0, // start of value 0
                6, 0, // start of value 1
                8, 0, 0, 0, // int32 offset for start of vtable
                0, 0, // pad
                44, // value 1, 0
                33,
            },
                builder.DataBuffer.ToFullArray());

            // check obj1
            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First field must be a struct with 12 bytes
            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 1, 1, true));
            // Second field must be a struct with 12 bytes
            Assert.IsTrue(verifier.VerifyField(checkOffset, 6, 1, 1, true));
            // Third field must be a struct with 12 bytes
            Assert.IsTrue(verifier.VerifyField(checkOffset, 8, 1, 1, true));
            // Check Error: 4. field did not exist
            Assert.IsFalse(verifier.VerifyField(checkOffset, 10, 1, 1, true));

            // check obj0
            checkOffset = 56;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First field must be a struct with 12 bytes
            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 1, 1, true));
            // Second field must be a struct with 12 bytes
            Assert.IsTrue(verifier.VerifyField(checkOffset, 6, 1, 1, true));
            // Check Error: 3. field did not exist
            Assert.IsFalse(verifier.VerifyField(checkOffset, 8, 1, 1, true));
            // Check Error: 4. field did not exist
            Assert.IsFalse(verifier.VerifyField(checkOffset, 10, 1, 1, true));
        }

        [FlatBuffersTestMethod]
        public void TestBunchOfBools()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(8);
            for (var i = 0; i < 8; i++)
            {
                builder.AddBool(i, true, false);
            }
            var off = builder.EndTable();
            builder.Finish(off);

            byte[] padded = new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,       // padding to 64 bytes

                24, 0, 0, 0,     // root of table, pointing to vtable offset (obj0)
                20, 0, // vtable bytes
                12, 0, // object length
                11, 0, // start of value 0
                10, 0, // start of value 1
                9, 0, // start of value 2
                8, 0, // start of value 3
                7, 0, // start of value 4
                6, 0, // start of value 5
                5, 0, // start of value 6
                4, 0, // start of value 7

                20, 0, 0, 0, // int32 offset for start of vtable

                1, 1, 1, 1,  // values
                1, 1, 1, 1,

            };
            Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray());

            // no padding in sized array
            byte[] unpadded = new byte[padded.Length - 28];
            Buffer.BlockCopy(padded, 28, unpadded, 0, unpadded.Length);
            Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray());

            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            for (var i = 0; i < 8; i++)
            {
                Assert.IsTrue(verifier.VerifyField(checkOffset, (short)(4 + i * 2), 1, 1, true));
            }
            Assert.IsFalse(verifier.VerifyField(checkOffset, (short)(4 + 8 * 2), 1, 1, true));
        }

        [FlatBuffersTestMethod]
        public void TestBunchOfBoolsSizePrefixed()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(8);
            for (var i = 0; i < 8; i++)
            {
                builder.AddBool(i, true, false);
            }
            var off = builder.EndTable();
            builder.FinishSizePrefixed(off);

            byte[] padded = new byte[]
            {
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,      // padding to 64 bytes

                36, 0, 0, 0,     // size prefix
                24, 0, 0, 0,     // root of table, pointing to vtable offset (obj0)
                20, 0, // vtable bytes
                12, 0, // object length
                11, 0, // start of value 0
                10, 0, // start of value 1
                9, 0, // start of value 2
                8, 0, // start of value 3
                7, 0, // start of value 4
                6, 0, // start of value 5
                5, 0, // start of value 6
                4, 0, // start of value 7

                20, 0, 0, 0, // int32 offset for start of vtable

                1, 1, 1, 1,  // values
                1, 1, 1, 1,

            };
            Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray());

            // no padding in sized array
            byte[] unpadded = new byte[padded.Length - 24];
            Buffer.BlockCopy(padded, 24, unpadded, 0, unpadded.Length);
            Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray());
        }

        [FlatBuffersTestMethod]
        public void TestWithFloat()
        {
            var builder = new FlatBufferBuilder(1);
            builder.StartTable(1);
            builder.AddFloat(0, 1, 0);
            builder.EndTable();


            Assert.ArrayEqual(new byte[]
            {
                0, 0,
                6, 0, // vtable bytes
                8, 0, // object length
                4, 0, // start of value 0
                6, 0, 0, 0, // int32 offset for start of vtable
                0, 0, 128, 63,  // value

            },
                builder.DataBuffer.ToFullArray());
            var verifier = new Verifier(builder.DataBuffer);
            uint checkOffset = 8;
            // table must be ok
            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
            // First Field must be float
            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 4, 4, true));
            // Check Error: First Field with to big size
            Assert.IsFalse(verifier.VerifyField(checkOffset, 4, 8, 4, true));
            // Check Error: First Field with to big padding
            Assert.IsFalse(verifier.VerifyField(checkOffset, 4, 4, 8, true));
        }

        private void CheckObjects(int fieldCount, int objectCount)
        {
            _lcg.Reset();

            const int testValuesMax = 11;

            var builder = new FlatBufferBuilder(1);

            var objects = new int[objectCount];

            for (var i = 0; i < objectCount; ++i)
            {
                builder.StartTable(fieldCount);

                for (var j = 0; j < fieldCount; ++j)
                {
                    var fieldType = _lcg.Next()%testValuesMax;

                    switch (fieldType)
                    {
                        case 0:
                        {
                            builder.AddBool(j, FuzzTestData.BoolValue, false);
                            break;
                        }
                        case 1:
                        {
                            builder.AddSbyte(j, FuzzTestData.Int8Value, 0);
                            break;
                        }
                        case 2:
                        {
                            builder.AddByte(j, FuzzTestData.UInt8Value, 0);
                            break;
                        }
                        case 3:
                        {
                            builder.AddShort(j, FuzzTestData.Int16Value, 0);
                            break;
                        }
                        case 4:
                        {
                            builder.AddUshort(j, FuzzTestData.UInt16Value, 0);
                            break;
                        }
                        case 5:
                        {
                            builder.AddInt(j, FuzzTestData.Int32Value, 0);
                            break;
                        }
                        case 6:
                        {
                            builder.AddUint(j, FuzzTestData.UInt32Value, 0);
                            break;
                        }
                        case 7:
                        {
                            builder.AddLong(j, FuzzTestData.Int64Value, 0);
                            break;
                        }
                        case 8:
                        {
                            builder.AddUlong(j, FuzzTestData.UInt64Value, 0);
                            break;
                        }
                        case 9:
                        {
                            builder.AddFloat(j, FuzzTestData.Float32Value, 0);
                            break;
                        }
                        case 10:
                        {
                            builder.AddDouble(j, FuzzTestData.Float64Value, 0);
                            break;
                        }
                        default:
                            throw new Exception("Unreachable");
                    }

                }

                var offset = builder.EndTable();

                // Store the object offset
                objects[i] = offset;
            }

            _lcg.Reset();

            // Test all objects are readable and return expected values...
            for (var i = 0; i < objectCount; ++i)
            {
                var table = new TestTable(builder.DataBuffer, builder.DataBuffer.Length - objects[i]);

                for (var j = 0; j < fieldCount; ++j)
                {
                    var fieldType = _lcg.Next() % testValuesMax;
                    var fc = 2 + j; // 2 == VtableMetadataFields
                    var f = fc * 2;

                    switch (fieldType)
                    {
                        case 0:
                        {
                            Assert.AreEqual(FuzzTestData.BoolValue, table.GetSlot(f, false));
                            break;
                        }
                        case 1:
                        {
                            Assert.AreEqual(FuzzTestData.Int8Value, table.GetSlot(f, (sbyte)0));
                            break;
                        }
                        case 2:
                        {
                            Assert.AreEqual(FuzzTestData.UInt8Value, table.GetSlot(f, (byte)0));
                            break;
                        }
                        case 3:
                        {
                            Assert.AreEqual(FuzzTestData.Int16Value, table.GetSlot(f, (short)0));
                            break;
                        }
                        case 4:
                        {
                            Assert.AreEqual(FuzzTestData.UInt16Value, table.GetSlot(f, (ushort)0));
                            break;
                        }
                        case 5:
                        {
                            Assert.AreEqual(FuzzTestData.Int32Value, table.GetSlot(f, (int)0));
                            break;
                        }
                        case 6:
                        {
                            Assert.AreEqual(FuzzTestData.UInt32Value, table.GetSlot(f, (uint)0));
                            break;
                        }
                        case 7:
                        {
                            Assert.AreEqual(FuzzTestData.Int64Value, table.GetSlot(f, (long)0));
                            break;
                        }
                        case 8:
                        {
                            Assert.AreEqual(FuzzTestData.UInt64Value, table.GetSlot(f, (ulong)0));
                            break;
                        }
                        case 9:
                        {
                            Assert.AreEqual(FuzzTestData.Float32Value, table.GetSlot(f, (float)0));
                            break;
                        }
                        case 10:
                        {
                            Assert.AreEqual(FuzzTestData.Float64Value, table.GetSlot(f, (double)0));
                            break;
                        }
                        default:
                            throw new Exception("Unreachable");
                    }

                }

            }

        }
    }
}