BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-29 20:42:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

[CS] Verifier (#7850)

Browse Source 
* Fix C/C++ Create<Type>Direct with sorted vectors

If a struct has a key the vector has to be sorted. To sort the vector
you can't use "const".

* Changes due to code review

* Improve code readability

* Add generate of JSON schema to string to lib

* option indent_step is supported

* Remove unused variables

* Fix break in test

* Fix style to be consistent with rest of the code

* [TS] Fix reserved words as arguments (#6955)

* [TS] Fix generation of reserved words in object api (#7106)

* [TS] Fix generation of object api

* [TS] Fix MakeCamel -> ConvertCase

* [C#] Fix collision of field name and type name

* [TS] Add test for struct of struct of struct

* Update generated files

* Add missing files

* [TS] Fix query of null/undefined fields in object api

* Add .Net verfier

* Add some fuzz tests for .Net

* Remove additional files

* Fix .net test

* Changes due to PR

* Fix generated files

---------

Co-authored-by: Derek Bailey <derekbailey@google.com>
This commit is contained in:
tira-misu
2023-04-06 00:29:14 +02:00
committed by GitHub
parent 2803983c70
commit 876a64aae1
37 changed files with 1952 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj
View File

@@ -46,6 +46,9 @@
<Compile Include="..\..\net\FlatBuffers\FlatBufferConstants.cs">
<Link>FlatBuffers\FlatBufferConstants.cs</Link>
</Compile>
<Compile Include="..\..\net\FlatBuffers\FlatBufferVerify.cs">
<Link>FlatBuffers\FlatBufferVerify.cs</Link>
</Compile>
<Compile Include="..\..\net\FlatBuffers\Struct.cs">
<Link>FlatBuffers\Struct.cs</Link>
</Compile>

5
tests/FlatBuffers.Test/FlatBuffersExampleTests.cs
View File

@@ -198,6 +198,9 @@ namespace Google.FlatBuffers.Test
private void TestBuffer(ByteBuffer bb)
{
bool test = Monster.VerifyMonster(bb);
Assert.AreEqual(true, test);
Monster monster = Monster.GetRootAsMonster(bb);
Assert.AreEqual(80, monster.Hp);
@@ -299,7 +302,7 @@ namespace Google.FlatBuffers.Test
var jsonText = File.ReadAllText(@"../monsterdata_test.json");
var mon = MonsterT.DeserializeFromJson(jsonText);
var fbb = new FlatBufferBuilder(1);
fbb.Finish(Monster.Pack(fbb, mon).Value);
Monster.FinishMonsterBuffer(fbb, Monster.Pack(fbb, mon));
TestBuffer(fbb.DataBuffer);
}

253
tests/FlatBuffers.Test/FlatBuffersFuzzTests.cs
View File

@@ -15,6 +15,7 @@
*/
using System;
using Google.FlatBuffers;
namespace Google.FlatBuffers.Test
{
@@ -204,9 +205,21 @@ namespace Google.FlatBuffers.Test
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]
[FlatBuffersTestMethod]
public void TestVTableWithOneBool_DefaultValue()
{
var builder = new FlatBufferBuilder(1);
@@ -223,6 +236,14 @@ namespace Google.FlatBuffers.Test
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]
@@ -232,7 +253,7 @@ namespace Google.FlatBuffers.Test
builder.StartTable(1);
Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
builder.AddShort(0, 0x789A, 0);
builder.EndTable();
int offset = builder.EndTable();
Assert.ArrayEqual(new byte[]
{
0, 0, // padding to 16 bytes
@@ -244,6 +265,18 @@ namespace Google.FlatBuffers.Test
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]
@@ -254,7 +287,7 @@ namespace Google.FlatBuffers.Test
Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
builder.AddShort(0, 0x3456, 0);
builder.AddShort(1, 0x789A, 0);
builder.EndTable();
int offset = builder.EndTable();
Assert.ArrayEqual(new byte[]
{
8, 0, // vtable bytes
@@ -266,6 +299,18 @@ namespace Google.FlatBuffers.Test
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]
@@ -276,7 +321,7 @@ namespace Google.FlatBuffers.Test
Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
builder.AddShort(0, 0x3456, 0);
builder.AddBool(1, true, false);
builder.EndTable();
int offset = builder.EndTable();
Assert.ArrayEqual(new byte[]
{
8, 0, // vtable bytes
@@ -288,6 +333,18 @@ namespace Google.FlatBuffers.Test
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]
@@ -315,6 +372,12 @@ namespace Google.FlatBuffers.Test
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]
@@ -342,7 +405,15 @@ namespace Google.FlatBuffers.Test
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]
@@ -373,6 +444,16 @@ namespace Google.FlatBuffers.Test
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]
@@ -403,8 +484,17 @@ namespace Google.FlatBuffers.Test
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()
{
@@ -437,6 +527,12 @@ namespace Google.FlatBuffers.Test
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]
@@ -470,6 +566,104 @@ namespace Google.FlatBuffers.Test
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]
@@ -521,6 +715,33 @@ namespace Google.FlatBuffers.Test
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]
@@ -569,6 +790,16 @@ namespace Google.FlatBuffers.Test
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]
@@ -639,6 +870,16 @@ namespace Google.FlatBuffers.Test
},
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)