BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-24 01:31:46 +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)

13
tests/KeywordTest/KeywordsInTable.cs
View File

@@ -92,4 +92,17 @@ public class KeywordsInTableT
}
static public class KeywordsInTableVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*Is*/, 4 /*KeywordTest.ABC*/, 4, false)
&& verifier.VerifyField(tablePos, 6 /*Private*/, 4 /*KeywordTest.@public*/, 4, false)
&& verifier.VerifyField(tablePos, 8 /*Type*/, 4 /*int*/, 4, false)
&& verifier.VerifyField(tablePos, 10 /*Default*/, 1 /*bool*/, 1, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

22
tests/KeywordTest/KeywordsInUnion.cs
View File

@@ -37,6 +37,28 @@ public class KeywordsInUnionUnion {
}
}
static public class KeywordsInUnionVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
{
bool result = true;
switch((KeywordsInUnion)typeId)
{
case KeywordsInUnion.@static:
result = KeywordTest.KeywordsInTableVerify.Verify(verifier, tablePos);
break;
case KeywordsInUnion.@internal:
result = KeywordTest.KeywordsInTableVerify.Verify(verifier, tablePos);
break;
default: result = true;
break;
}
return result;
}
}
public class KeywordsInUnionUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
public override bool CanConvert(System.Type objectType) {
return objectType == typeof(KeywordsInUnionUnion) || objectType == typeof(System.Collections.Generic.List<KeywordsInUnionUnion>);

11
tests/KeywordTest/Table2.cs
View File

@@ -91,4 +91,15 @@ public class Table2T
}
static public class Table2Verify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*TypeType*/, 1 /*KeywordTest.KeywordsInUnion*/, 1, false)
&& verifier.VerifyUnion(tablePos, 4, 6 /*Type*/, KeywordTest.KeywordsInUnionVerify.Verify, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

25
tests/MyGame/Example/Any.cs
View File

@@ -41,6 +41,31 @@ public class AnyUnion {
}
}
static public class AnyVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
{
bool result = true;
switch((Any)typeId)
{
case Any.Monster:
result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
break;
case Any.TestSimpleTableWithEnum:
result = MyGame.Example.TestSimpleTableWithEnumVerify.Verify(verifier, tablePos);
break;
case Any.MyGame_Example2_Monster:
result = MyGame.Example2.MonsterVerify.Verify(verifier, tablePos);
break;
default: result = true;
break;
}
return result;
}
}
public class AnyUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
public override bool CanConvert(System.Type objectType) {
return objectType == typeof(AnyUnion) || objectType == typeof(System.Collections.Generic.List<AnyUnion>);

25
tests/MyGame/Example/AnyAmbiguousAliases.cs
View File

@@ -41,6 +41,31 @@ public class AnyAmbiguousAliasesUnion {
}
}
static public class AnyAmbiguousAliasesVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
{
bool result = true;
switch((AnyAmbiguousAliases)typeId)
{
case AnyAmbiguousAliases.M1:
result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
break;
case AnyAmbiguousAliases.M2:
result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
break;
case AnyAmbiguousAliases.M3:
result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
break;
default: result = true;
break;
}
return result;
}
}
public class AnyAmbiguousAliasesUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
public override bool CanConvert(System.Type objectType) {
return objectType == typeof(AnyAmbiguousAliasesUnion) || objectType == typeof(System.Collections.Generic.List<AnyAmbiguousAliasesUnion>);

25
tests/MyGame/Example/AnyUniqueAliases.cs
View File

@@ -41,6 +41,31 @@ public class AnyUniqueAliasesUnion {
}
}
static public class AnyUniqueAliasesVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
{
bool result = true;
switch((AnyUniqueAliases)typeId)
{
case AnyUniqueAliases.M:
result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
break;
case AnyUniqueAliases.TS:
result = MyGame.Example.TestSimpleTableWithEnumVerify.Verify(verifier, tablePos);
break;
case AnyUniqueAliases.M2:
result = MyGame.Example2.MonsterVerify.Verify(verifier, tablePos);
break;
default: result = true;
break;
}
return result;
}
}
public class AnyUniqueAliasesUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
public override bool CanConvert(System.Type objectType) {
return objectType == typeof(AnyUniqueAliasesUnion) || objectType == typeof(System.Collections.Generic.List<AnyUniqueAliasesUnion>);

11
tests/MyGame/Example/ArrayTable.cs
View File

@@ -17,6 +17,7 @@ public struct ArrayTable : IFlatbufferObject
public static ArrayTable GetRootAsArrayTable(ByteBuffer _bb) { return GetRootAsArrayTable(_bb, new ArrayTable()); }
public static ArrayTable GetRootAsArrayTable(ByteBuffer _bb, ArrayTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public static bool ArrayTableBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "ARRT"); }
public static bool VerifyArrayTable(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("ARRT", false, ArrayTableVerify.Verify); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
public ArrayTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
@@ -72,4 +73,14 @@ public class ArrayTableT
}
static public class ArrayTableVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*A*/, 160 /*MyGame.Example.ArrayStruct*/, 8, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

71
tests/MyGame/Example/Monster.cs
View File

@@ -18,6 +18,7 @@ public struct Monster : IFlatbufferObject
public static Monster GetRootAsMonster(ByteBuffer _bb) { return GetRootAsMonster(_bb, new Monster()); }
public static Monster GetRootAsMonster(ByteBuffer _bb, Monster obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public static bool MonsterBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MONS"); }
public static bool VerifyMonster(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("MONS", false, MonsterVerify.Verify); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
public Monster __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
@@ -1100,4 +1101,74 @@ public class MonsterT
}
static public class MonsterVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*Pos*/, 32 /*MyGame.Example.Vec3*/, 8, false)
&& verifier.VerifyField(tablePos, 6 /*Mana*/, 2 /*short*/, 2, false)
&& verifier.VerifyField(tablePos, 8 /*Hp*/, 2 /*short*/, 2, false)
&& verifier.VerifyString(tablePos, 10 /*Name*/, true)
&& verifier.VerifyVectorOfData(tablePos, 14 /*Inventory*/, 1 /*byte*/, false)
&& verifier.VerifyField(tablePos, 16 /*Color*/, 1 /*MyGame.Example.Color*/, 1, false)
&& verifier.VerifyField(tablePos, 18 /*TestType*/, 1 /*MyGame.Example.Any*/, 1, false)
&& verifier.VerifyUnion(tablePos, 18, 20 /*Test*/, MyGame.Example.AnyVerify.Verify, false)
&& verifier.VerifyVectorOfData(tablePos, 22 /*Test4*/, 4 /*MyGame.Example.Test*/, false)
&& verifier.VerifyVectorOfStrings(tablePos, 24 /*Testarrayofstring*/, false)
&& verifier.VerifyVectorOfTables(tablePos, 26 /*Testarrayoftables*/, MyGame.Example.MonsterVerify.Verify, false)
&& verifier.VerifyTable(tablePos, 28 /*Enemy*/, MyGame.Example.MonsterVerify.Verify, false)
&& verifier.VerifyNestedBuffer(tablePos, 30 /*Testnestedflatbuffer*/, MyGame.Example.MonsterVerify.Verify, false)
&& verifier.VerifyTable(tablePos, 32 /*Testempty*/, MyGame.Example.StatVerify.Verify, false)
&& verifier.VerifyField(tablePos, 34 /*Testbool*/, 1 /*bool*/, 1, false)
&& verifier.VerifyField(tablePos, 36 /*Testhashs32Fnv1*/, 4 /*int*/, 4, false)
&& verifier.VerifyField(tablePos, 38 /*Testhashu32Fnv1*/, 4 /*uint*/, 4, false)
&& verifier.VerifyField(tablePos, 40 /*Testhashs64Fnv1*/, 8 /*long*/, 8, false)
&& verifier.VerifyField(tablePos, 42 /*Testhashu64Fnv1*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyField(tablePos, 44 /*Testhashs32Fnv1a*/, 4 /*int*/, 4, false)
&& verifier.VerifyField(tablePos, 46 /*Testhashu32Fnv1a*/, 4 /*uint*/, 4, false)
&& verifier.VerifyField(tablePos, 48 /*Testhashs64Fnv1a*/, 8 /*long*/, 8, false)
&& verifier.VerifyField(tablePos, 50 /*Testhashu64Fnv1a*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyVectorOfData(tablePos, 52 /*Testarrayofbools*/, 1 /*bool*/, false)
&& verifier.VerifyField(tablePos, 54 /*Testf*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 56 /*Testf2*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 58 /*Testf3*/, 4 /*float*/, 4, false)
&& verifier.VerifyVectorOfStrings(tablePos, 60 /*Testarrayofstring2*/, false)
&& verifier.VerifyVectorOfData(tablePos, 62 /*Testarrayofsortedstruct*/, 8 /*MyGame.Example.Ability*/, false)
&& verifier.VerifyNestedBuffer(tablePos, 64 /*Flex*/, null, false)
&& verifier.VerifyVectorOfData(tablePos, 66 /*Test5*/, 4 /*MyGame.Example.Test*/, false)
&& verifier.VerifyVectorOfData(tablePos, 68 /*VectorOfLongs*/, 8 /*long*/, false)
&& verifier.VerifyVectorOfData(tablePos, 70 /*VectorOfDoubles*/, 8 /*double*/, false)
&& verifier.VerifyTable(tablePos, 72 /*ParentNamespaceTest*/, MyGame.InParentNamespaceVerify.Verify, false)
&& verifier.VerifyVectorOfTables(tablePos, 74 /*VectorOfReferrables*/, MyGame.Example.ReferrableVerify.Verify, false)
&& verifier.VerifyField(tablePos, 76 /*SingleWeakReference*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyVectorOfData(tablePos, 78 /*VectorOfWeakReferences*/, 8 /*ulong*/, false)
&& verifier.VerifyVectorOfTables(tablePos, 80 /*VectorOfStrongReferrables*/, MyGame.Example.ReferrableVerify.Verify, false)
&& verifier.VerifyField(tablePos, 82 /*CoOwningReference*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyVectorOfData(tablePos, 84 /*VectorOfCoOwningReferences*/, 8 /*ulong*/, false)
&& verifier.VerifyField(tablePos, 86 /*NonOwningReference*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyVectorOfData(tablePos, 88 /*VectorOfNonOwningReferences*/, 8 /*ulong*/, false)
&& verifier.VerifyField(tablePos, 90 /*AnyUniqueType*/, 1 /*MyGame.Example.AnyUniqueAliases*/, 1, false)
&& verifier.VerifyUnion(tablePos, 90, 92 /*AnyUnique*/, MyGame.Example.AnyUniqueAliasesVerify.Verify, false)
&& verifier.VerifyField(tablePos, 94 /*AnyAmbiguousType*/, 1 /*MyGame.Example.AnyAmbiguousAliases*/, 1, false)
&& verifier.VerifyUnion(tablePos, 94, 96 /*AnyAmbiguous*/, MyGame.Example.AnyAmbiguousAliasesVerify.Verify, false)
&& verifier.VerifyVectorOfData(tablePos, 98 /*VectorOfEnums*/, 1 /*MyGame.Example.Color*/, false)
&& verifier.VerifyField(tablePos, 100 /*SignedEnum*/, 1 /*MyGame.Example.Race*/, 1, false)
&& verifier.VerifyNestedBuffer(tablePos, 102 /*Testrequirednestedflatbuffer*/, MyGame.Example.MonsterVerify.Verify, false)
&& verifier.VerifyVectorOfTables(tablePos, 104 /*ScalarKeySortedTables*/, MyGame.Example.StatVerify.Verify, false)
&& verifier.VerifyField(tablePos, 106 /*NativeInline*/, 4 /*MyGame.Example.Test*/, 2, false)
&& verifier.VerifyField(tablePos, 108 /*LongEnumNonEnumDefault*/, 8 /*MyGame.Example.LongEnum*/, 8, false)
&& verifier.VerifyField(tablePos, 110 /*LongEnumNormalDefault*/, 8 /*MyGame.Example.LongEnum*/, 8, false)
&& verifier.VerifyField(tablePos, 112 /*NanDefault*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 114 /*InfDefault*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 116 /*PositiveInfDefault*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 118 /*InfinityDefault*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 120 /*PositiveInfinityDefault*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 122 /*NegativeInfDefault*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 124 /*NegativeInfinityDefault*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 126 /*DoubleInfDefault*/, 8 /*double*/, 8, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

10
tests/MyGame/Example/Referrable.cs
View File

@@ -92,4 +92,14 @@ public class ReferrableT
}
static public class ReferrableVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

12
tests/MyGame/Example/Stat.cs
View File

@@ -117,4 +117,16 @@ public class StatT
}
static public class StatVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyString(tablePos, 4 /*Id*/, false)
&& verifier.VerifyField(tablePos, 6 /*Val*/, 8 /*long*/, 8, false)
&& verifier.VerifyField(tablePos, 8 /*Count*/, 2 /*ushort*/, 2, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

10
tests/MyGame/Example/TestSimpleTableWithEnum.cs
View File

@@ -62,4 +62,14 @@ internal partial class TestSimpleTableWithEnumT
}
static public class TestSimpleTableWithEnumVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*Color*/, 1 /*MyGame.Example.Color*/, 1, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

21
tests/MyGame/Example/TypeAliases.cs
View File

@@ -208,4 +208,25 @@ public class TypeAliasesT
}
static public class TypeAliasesVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*I8*/, 1 /*sbyte*/, 1, false)
&& verifier.VerifyField(tablePos, 6 /*U8*/, 1 /*byte*/, 1, false)
&& verifier.VerifyField(tablePos, 8 /*I16*/, 2 /*short*/, 2, false)
&& verifier.VerifyField(tablePos, 10 /*U16*/, 2 /*ushort*/, 2, false)
&& verifier.VerifyField(tablePos, 12 /*I32*/, 4 /*int*/, 4, false)
&& verifier.VerifyField(tablePos, 14 /*U32*/, 4 /*uint*/, 4, false)
&& verifier.VerifyField(tablePos, 16 /*I64*/, 8 /*long*/, 8, false)
&& verifier.VerifyField(tablePos, 18 /*U64*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyField(tablePos, 20 /*F32*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 22 /*F64*/, 8 /*double*/, 8, false)
&& verifier.VerifyVectorOfData(tablePos, 24 /*V8*/, 1 /*sbyte*/, false)
&& verifier.VerifyVectorOfData(tablePos, 26 /*Vf64*/, 8 /*double*/, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

9
tests/MyGame/Example2/Monster.cs
View File

@@ -47,4 +47,13 @@ public class MonsterT
}
static public class MonsterVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

9
tests/MyGame/InParentNamespace.cs
View File

@@ -47,4 +47,13 @@ public class InParentNamespaceT
}
static public class InParentNamespaceVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

20
tests/MyGame/MonsterExtra.cs
View File

@@ -17,6 +17,7 @@ public struct MonsterExtra : IFlatbufferObject
public static MonsterExtra GetRootAsMonsterExtra(ByteBuffer _bb) { return GetRootAsMonsterExtra(_bb, new MonsterExtra()); }
public static MonsterExtra GetRootAsMonsterExtra(ByteBuffer _bb, MonsterExtra obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public static bool MonsterExtraBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MONE"); }
public static bool VerifyMonsterExtra(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("MONE", false, MonsterExtraVerify.Verify); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
public MonsterExtra __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
@@ -206,4 +207,23 @@ public class MonsterExtraT
}
static public class MonsterExtraVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*D0*/, 8 /*double*/, 8, false)
&& verifier.VerifyField(tablePos, 6 /*D1*/, 8 /*double*/, 8, false)
&& verifier.VerifyField(tablePos, 8 /*D2*/, 8 /*double*/, 8, false)
&& verifier.VerifyField(tablePos, 10 /*D3*/, 8 /*double*/, 8, false)
&& verifier.VerifyField(tablePos, 12 /*F0*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 14 /*F1*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 16 /*F2*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 18 /*F3*/, 4 /*float*/, 4, false)
&& verifier.VerifyVectorOfData(tablePos, 20 /*Dvec*/, 8 /*double*/, false)
&& verifier.VerifyVectorOfData(tablePos, 22 /*Fvec*/, 4 /*float*/, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

10
tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs
View File

@@ -62,4 +62,14 @@ public class TableInNestedNST
}
static public class TableInNestedNSVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*Foo*/, 4 /*int*/, 4, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

19
tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.cs
View File

@@ -33,6 +33,25 @@ public class UnionInNestedNSUnion {
}
}
static public class UnionInNestedNSVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
{
bool result = true;
switch((UnionInNestedNS)typeId)
{
case UnionInNestedNS.TableInNestedNS:
result = NamespaceA.NamespaceB.TableInNestedNSVerify.Verify(verifier, tablePos);
break;
default: result = true;
break;
}
return result;
}
}
public class UnionInNestedNSUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
public override bool CanConvert(System.Type objectType) {
return objectType == typeof(UnionInNestedNSUnion) || objectType == typeof(System.Collections.Generic.List<UnionInNestedNSUnion>);

10
tests/namespace_test/NamespaceA/SecondTableInA.cs
View File

@@ -62,4 +62,14 @@ public class SecondTableInAT
}
static public class SecondTableInAVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyTable(tablePos, 4 /*ReferToC*/, NamespaceC.TableInCVerify.Verify, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

14
tests/namespace_test/NamespaceA/TableInFirstNS.cs
View File

@@ -116,4 +116,18 @@ public class TableInFirstNST
}
static public class TableInFirstNSVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyTable(tablePos, 4 /*FooTable*/, NamespaceA.NamespaceB.TableInNestedNSVerify.Verify, false)
&& verifier.VerifyField(tablePos, 6 /*FooEnum*/, 1 /*NamespaceA.NamespaceB.EnumInNestedNS*/, 1, false)
&& verifier.VerifyField(tablePos, 8 /*FooUnionType*/, 1 /*NamespaceA.NamespaceB.UnionInNestedNS*/, 1, false)
&& verifier.VerifyUnion(tablePos, 8, 10 /*FooUnion*/, NamespaceA.NamespaceB.UnionInNestedNSVerify.Verify, false)
&& verifier.VerifyField(tablePos, 12 /*FooStruct*/, 8 /*NamespaceA.NamespaceB.StructInNestedNS*/, 4, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

11
tests/namespace_test/NamespaceC/TableInC.cs
View File

@@ -72,4 +72,15 @@ public class TableInCT
}
static public class TableInCVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyTable(tablePos, 4 /*ReferToA1*/, NamespaceA.TableInFirstNSVerify.Verify, false)
&& verifier.VerifyTable(tablePos, 6 /*ReferToA2*/, NamespaceA.SecondTableInAVerify.Verify, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

10
tests/nested_namespace_test/nested_namespace_test3_generated.cs
View File

@@ -62,4 +62,14 @@ public class ColorTestTableT
}
static public class ColorTestTableVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*Color*/, 1 /*global::NamespaceB.Color*/, 1, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

46
tests/optional_scalars/ScalarStuff.cs
View File

@@ -17,6 +17,7 @@ public struct ScalarStuff : IFlatbufferObject
public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb) { return GetRootAsScalarStuff(_bb, new ScalarStuff()); }
public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb, ScalarStuff obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public static bool ScalarStuffBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "NULL"); }
public static bool VerifyScalarStuff(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("NULL", false, ScalarStuffVerify.Verify); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
public ScalarStuff __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
@@ -351,4 +352,49 @@ public class ScalarStuffT
}
static public class ScalarStuffVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*JustI8*/, 1 /*sbyte*/, 1, false)
&& verifier.VerifyField(tablePos, 6 /*MaybeI8*/, 1 /*sbyte*/, 1, false)
&& verifier.VerifyField(tablePos, 8 /*DefaultI8*/, 1 /*sbyte*/, 1, false)
&& verifier.VerifyField(tablePos, 10 /*JustU8*/, 1 /*byte*/, 1, false)
&& verifier.VerifyField(tablePos, 12 /*MaybeU8*/, 1 /*byte*/, 1, false)
&& verifier.VerifyField(tablePos, 14 /*DefaultU8*/, 1 /*byte*/, 1, false)
&& verifier.VerifyField(tablePos, 16 /*JustI16*/, 2 /*short*/, 2, false)
&& verifier.VerifyField(tablePos, 18 /*MaybeI16*/, 2 /*short*/, 2, false)
&& verifier.VerifyField(tablePos, 20 /*DefaultI16*/, 2 /*short*/, 2, false)
&& verifier.VerifyField(tablePos, 22 /*JustU16*/, 2 /*ushort*/, 2, false)
&& verifier.VerifyField(tablePos, 24 /*MaybeU16*/, 2 /*ushort*/, 2, false)
&& verifier.VerifyField(tablePos, 26 /*DefaultU16*/, 2 /*ushort*/, 2, false)
&& verifier.VerifyField(tablePos, 28 /*JustI32*/, 4 /*int*/, 4, false)
&& verifier.VerifyField(tablePos, 30 /*MaybeI32*/, 4 /*int*/, 4, false)
&& verifier.VerifyField(tablePos, 32 /*DefaultI32*/, 4 /*int*/, 4, false)
&& verifier.VerifyField(tablePos, 34 /*JustU32*/, 4 /*uint*/, 4, false)
&& verifier.VerifyField(tablePos, 36 /*MaybeU32*/, 4 /*uint*/, 4, false)
&& verifier.VerifyField(tablePos, 38 /*DefaultU32*/, 4 /*uint*/, 4, false)
&& verifier.VerifyField(tablePos, 40 /*JustI64*/, 8 /*long*/, 8, false)
&& verifier.VerifyField(tablePos, 42 /*MaybeI64*/, 8 /*long*/, 8, false)
&& verifier.VerifyField(tablePos, 44 /*DefaultI64*/, 8 /*long*/, 8, false)
&& verifier.VerifyField(tablePos, 46 /*JustU64*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyField(tablePos, 48 /*MaybeU64*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyField(tablePos, 50 /*DefaultU64*/, 8 /*ulong*/, 8, false)
&& verifier.VerifyField(tablePos, 52 /*JustF32*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 54 /*MaybeF32*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 56 /*DefaultF32*/, 4 /*float*/, 4, false)
&& verifier.VerifyField(tablePos, 58 /*JustF64*/, 8 /*double*/, 8, false)
&& verifier.VerifyField(tablePos, 60 /*MaybeF64*/, 8 /*double*/, 8, false)
&& verifier.VerifyField(tablePos, 62 /*DefaultF64*/, 8 /*double*/, 8, false)
&& verifier.VerifyField(tablePos, 64 /*JustBool*/, 1 /*bool*/, 1, false)
&& verifier.VerifyField(tablePos, 66 /*MaybeBool*/, 1 /*bool*/, 1, false)
&& verifier.VerifyField(tablePos, 68 /*DefaultBool*/, 1 /*bool*/, 1, false)
&& verifier.VerifyField(tablePos, 70 /*JustEnum*/, 1 /*optional_scalars.OptionalByte*/, 1, false)
&& verifier.VerifyField(tablePos, 72 /*MaybeEnum*/, 1 /*optional_scalars.OptionalByte*/, 1, false)
&& verifier.VerifyField(tablePos, 74 /*DefaultEnum*/, 1 /*optional_scalars.OptionalByte*/, 1, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

11
tests/type_field_collsion/Collision.cs
View File

@@ -16,6 +16,7 @@ public struct Collision : IFlatbufferObject
public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
public static Collision GetRootAsCollision(ByteBuffer _bb) { return GetRootAsCollision(_bb, new Collision()); }
public static Collision GetRootAsCollision(ByteBuffer _bb, Collision obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public static bool VerifyCollision(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, CollisionVerify.Verify); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
public Collision __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
@@ -70,4 +71,14 @@ public class CollisionT
}
static public class CollisionVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*Collision*/, 4 /*int*/, 4, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

74
tests/union_value_collsion/union_value_collision_generated.cs
View File

@@ -37,6 +37,25 @@ public class ValueUnion {
}
}
static public class ValueVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
{
bool result = true;
switch((Value)typeId)
{
case Value.IntValue:
result = union_value_collsion.IntValueVerify.Verify(verifier, tablePos);
break;
default: result = true;
break;
}
return result;
}
}
public class ValueUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
public override bool CanConvert(System.Type objectType) {
return objectType == typeof(ValueUnion) || objectType == typeof(System.Collections.Generic.List<ValueUnion>);
@@ -106,6 +125,25 @@ public class OtherUnion {
}
}
static public class OtherVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
{
bool result = true;
switch((Other)typeId)
{
case Other.IntValue:
result = union_value_collsion.IntValueVerify.Verify(verifier, tablePos);
break;
default: result = true;
break;
}
return result;
}
}
public class OtherUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
public override bool CanConvert(System.Type objectType) {
return objectType == typeof(OtherUnion) || objectType == typeof(System.Collections.Generic.List<OtherUnion>);
@@ -198,6 +236,16 @@ public class IntValueT
}
}
static public class IntValueVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*Value*/, 4 /*int*/, 4, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
public struct Collide : IFlatbufferObject
{
private Table __p;
@@ -302,6 +350,17 @@ public class CollideT
}
}
static public class CollideVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyString(tablePos, 4 /*Collide*/, true)
&& verifier.VerifyString(tablePos, 6 /*Value*/, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
public struct Collision : IFlatbufferObject
{
private Table __p;
@@ -309,6 +368,7 @@ public struct Collision : IFlatbufferObject
public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
public static Collision GetRootAsCollision(ByteBuffer _bb) { return GetRootAsCollision(_bb, new Collision()); }
public static Collision GetRootAsCollision(ByteBuffer _bb, Collision obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public static bool VerifyCollision(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, CollisionVerify.Verify); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
public Collision __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
@@ -454,4 +514,18 @@ public class CollisionT
}
static public class CollisionVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*SomeValueType*/, 1 /*union_value_collsion.Value*/, 1, false)
&& verifier.VerifyUnion(tablePos, 4, 6 /*SomeValue*/, union_value_collsion.ValueVerify.Verify, false)
&& verifier.VerifyField(tablePos, 8 /*ValueType*/, 1 /*union_value_collsion.Other*/, 1, false)
&& verifier.VerifyUnion(tablePos, 8, 10 /*Value*/, union_value_collsion.OtherVerify.Verify, false)
&& verifier.VerifyVectorOfTables(tablePos, 12 /*Collide*/, union_value_collsion.CollisionVerify.Verify, false)
&& verifier.VerifyTableEnd(tablePos);
}
}
}

10
tests/union_vector/Attacker.cs
View File

@@ -58,3 +58,13 @@ public class AttackerT
}
}
static public class AttackerVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*SwordAttackDamage*/, 4 /*int*/, 4, false)
&& verifier.VerifyTableEnd(tablePos);
}
}

34
tests/union_vector/Character.cs
View File

@@ -50,6 +50,40 @@ public class CharacterUnion {
}
}
static public class CharacterVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
{
bool result = true;
switch((Character)typeId)
{
case Character.MuLan:
result = AttackerVerify.Verify(verifier, tablePos);
break;
case Character.Rapunzel:
result = verifier.VerifyUnionData(tablePos, 4, 4);
break;
case Character.Belle:
result = verifier.VerifyUnionData(tablePos, 4, 4);
break;
case Character.BookFan:
result = verifier.VerifyUnionData(tablePos, 4, 4);
break;
case Character.Other:
result = verifier.VerifyUnionString(tablePos);
break;
case Character.Unused:
result = verifier.VerifyUnionString(tablePos);
break;
default: result = true;
break;
}
return result;
}
}
public class CharacterUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
public override bool CanConvert(System.Type objectType) {
return objectType == typeof(CharacterUnion) || objectType == typeof(System.Collections.Generic.List<CharacterUnion>);

22
tests/union_vector/Gadget.cs
View File

@@ -34,6 +34,28 @@ public class GadgetUnion {
}
}
static public class GadgetVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
{
bool result = true;
switch((Gadget)typeId)
{
case Gadget.FallingTub:
result = verifier.VerifyUnionData(tablePos, 4, 4);
break;
case Gadget.HandFan:
result = HandFanVerify.Verify(verifier, tablePos);
break;
default: result = true;
break;
}
return result;
}
}
public class GadgetUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
public override bool CanConvert(System.Type objectType) {
return objectType == typeof(GadgetUnion) || objectType == typeof(System.Collections.Generic.List<GadgetUnion>);

10
tests/union_vector/HandFan.cs
View File

@@ -58,3 +58,13 @@ public class HandFanT
}
}
static public class HandFanVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*Length*/, 4 /*int*/, 4, false)
&& verifier.VerifyTableEnd(tablePos);
}
}

13
tests/union_vector/Movie.cs
View File

@@ -14,6 +14,7 @@ public struct Movie : IFlatbufferObject
public static Movie GetRootAsMovie(ByteBuffer _bb) { return GetRootAsMovie(_bb, new Movie()); }
public static Movie GetRootAsMovie(ByteBuffer _bb, Movie obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public static bool MovieBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MOVI"); }
public static bool VerifyMovie(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("MOVI", false, MovieVerify.Verify); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
public Movie __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
@@ -211,3 +212,15 @@ public class MovieT
}
}
static public class MovieVerify
{
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
{
return verifier.VerifyTableStart(tablePos)
&& verifier.VerifyField(tablePos, 4 /*MainCharacterType*/, 1 /*Character*/, 1, false)
&& verifier.VerifyUnion(tablePos, 4, 6 /*MainCharacter*/, CharacterVerify.Verify, false)
&& verifier.VerifyVectorOfData(tablePos, 8 /*CharactersType*/, 1 /*Character*/, false)
&& verifier.VerifyTableEnd(tablePos);
}
}