public void CanCreateNewFlatBufferFromScratch()
{
// Second, let's create a FlatBuffer from scratch in C#, and test it also.
// We use an initial size of 1 to exercise the reallocation algorithm,
// normally a size larger than the typical FlatBuffer you generate would be
// better for performance.
var fbb = new FlatBufferBuilder(1);
// We set up the same values as monsterdata.json:
var str = fbb.CreateString("MyMonster");
var test1 = fbb.CreateString("test1");
var test2 = fbb.CreateString("test2");
Monster.StartInventoryVector(fbb, 5);
for (int i = 4; i >= 0; i--)
{
fbb.AddByte((byte)i);
}
var inv = fbb.EndVector();
var fred = fbb.CreateString("Fred");
Monster.StartMonster(fbb);
Monster.AddName(fbb, fred);
var mon2 = Monster.EndMonster(fbb);
Monster.StartTest4Vector(fbb, 2);
MyGame.Example.Test.CreateTest(fbb, (short)10, (sbyte)20);
MyGame.Example.Test.CreateTest(fbb, (short)30, (sbyte)40);
var test4 = fbb.EndVector();
Monster.StartTestarrayofstringVector(fbb, 2);
fbb.AddOffset(test2);
fbb.AddOffset(test1);
var testArrayOfString = fbb.EndVector();
Monster.StartMonster(fbb);
Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
Color.Green, (short)5, (sbyte)6));
Monster.AddHp(fbb, (short)80);
Monster.AddName(fbb, str);
Monster.AddInventory(fbb, inv);
Monster.AddTestType(fbb, (byte)1);
Monster.AddTest(fbb, mon2);
Monster.AddTest4(fbb, test4);
Monster.AddTestarrayofstring(fbb, testArrayOfString);
var mon = Monster.EndMonster(fbb);
fbb.Finish(mon);
// Dump to output directory so we can inspect later, if needed
using (var ms = new MemoryStream(fbb.DataBuffer().Data, fbb.DataBuffer().position(), fbb.Offset()))
{
var data = ms.ToArray();
File.WriteAllBytes(@"Resources/monsterdata_cstest.mon",data);
}
// Now assert the buffer
TestBuffer(fbb.DataBuffer());
}
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.StartObject(1);
builder.AddOffset(0, vecEnd.Value, 0);
builder.EndObject();
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.Data);
}
public static void AddLocation(FlatBufferBuilder builder, StringOffset locationOffset)
{
builder.AddOffset(3, locationOffset.Value, 0);
}
public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset)
{
builder.AddOffset(1, nameOffset.Value, 0);
}
public static void AddEntities(FlatBufferBuilder builder, VectorOffset entitiesOffset)
{
builder.AddOffset(0, entitiesOffset.Value, 0);
}
public static void AddDvec(FlatBufferBuilder builder, VectorOffset dvecOffset)
{
builder.AddOffset(8, dvecOffset.Value, 0);
}
public static void AddReferToA2(FlatBufferBuilder builder, Offset <NamespaceA.SecondTableInA> referToA2Offset)
{
builder.AddOffset(1, referToA2Offset.Value, 0);
}
public static void AddUnitconfigTRS(FlatBufferBuilder builder, VectorOffset unitconfigTRSOffset)
{
builder.AddOffset(0, unitconfigTRSOffset.Value, 0);
}
public static void AddRightHand(FlatBufferBuilder builder, Offset <types.fbs.HandData> rightHandOffset)
{
builder.AddOffset(1, rightHandOffset.Value, 0);
}
public static void AddHeader(FlatBufferBuilder builder, Offset <types.fbs.BufferHeader> headerOffset)
{
builder.AddOffset(0, headerOffset.Value, 0);
}
public static void AddCharacters(FlatBufferBuilder builder, VectorOffset charactersOffset)
{
builder.AddOffset(3, charactersOffset.Value, 0);
}
public static void AddMainCharacter(FlatBufferBuilder builder, int mainCharacterOffset)
{
builder.AddOffset(1, mainCharacterOffset, 0);
}
public static void AddFrame(FlatBufferBuilder builder, StringOffset frameOffset)
{
builder.AddOffset(0, frameOffset.Value, 0);
}
public static void AddTiming(FlatBufferBuilder builder, Offset <LongPair> timingOffset)
{
builder.AddOffset(2, timingOffset.Value, 0);
}
public static void AddHash(FlatBufferBuilder builder, VectorOffset hashOffset)
{
builder.AddOffset(18, hashOffset.Value, 0);
}
public void TestVTableWithEmptyVectorAndScalars()
{
var builder = new FlatBufferBuilder(1);
builder.StartVector(sizeof(byte), 0, 1);
var vecEnd = builder.EndVector();
builder.StartObject(2);
builder.AddShort(0, 55, 0);
builder.AddOffset(1, vecEnd.Value, 0);
builder.EndObject();
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.Data);
}
public void CanCreateNewFlatBufferFromScratch()
{
// Second, let's create a FlatBuffer from scratch in C#, and test it also.
// We use an initial size of 1 to exercise the reallocation algorithm,
// normally a size larger than the typical FlatBuffer you generate would be
// better for performance.
var fbb = new FlatBufferBuilder(1);
// We set up the same values as monsterdata.json:
var str = fbb.CreateString("MyMonster");
var test1 = fbb.CreateString("test1");
var test2 = fbb.CreateString("test2");
Monster.StartInventoryVector(fbb, 5);
for (int i = 4; i >= 0; i--)
{
fbb.AddByte((byte)i);
}
var inv = fbb.EndVector();
var fred = fbb.CreateString("Fred");
Monster.StartMonster(fbb);
Monster.AddName(fbb, fred);
var mon2 = Monster.EndMonster(fbb);
Monster.StartTest4Vector(fbb, 2);
MyGame.Example.Test.CreateTest(fbb, (short)10, (sbyte)20);
MyGame.Example.Test.CreateTest(fbb, (short)30, (sbyte)40);
var test4 = fbb.EndVector();
Monster.StartTestarrayofstringVector(fbb, 2);
fbb.AddOffset(test2.Value);
fbb.AddOffset(test1.Value);
var testArrayOfString = fbb.EndVector();
Monster.StartMonster(fbb);
Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
Color.Green, (short)5, (sbyte)6));
Monster.AddHp(fbb, (short)80);
Monster.AddName(fbb, str);
Monster.AddInventory(fbb, inv);
Monster.AddTestType(fbb, Any.Monster);
Monster.AddTest(fbb, mon2.Value);
Monster.AddTest4(fbb, test4);
Monster.AddTestarrayofstring(fbb, testArrayOfString);
Monster.AddTestbool(fbb, false);
var mon = Monster.EndMonster(fbb);
Monster.FinishMonsterBuffer(fbb, mon);
// Dump to output directory so we can inspect later, if needed
using (var ms = new MemoryStream(fbb.DataBuffer.Data, fbb.DataBuffer.Position, fbb.Offset))
{
var data = ms.ToArray();
File.WriteAllBytes(@"Resources/monsterdata_cstest.mon",data);
}
// Now assert the buffer
TestBuffer(fbb.DataBuffer);
//Attempt to mutate Monster fields and check whether the buffer has been mutated properly
// revert to original values after testing
Monster monster = Monster.GetRootAsMonster(fbb.DataBuffer);
// mana is optional and does not exist in the buffer so the mutation should fail
// the mana field should retain its default value
Assert.AreEqual(monster.MutateMana((short)10), false);
Assert.AreEqual(monster.Mana, (short)150);
// testType is an existing field and mutating it should succeed
Assert.AreEqual(monster.TestType, Any.Monster);
Assert.AreEqual(monster.MutateTestType(Any.NONE), true);
Assert.AreEqual(monster.TestType, Any.NONE);
Assert.AreEqual(monster.MutateTestType(Any.Monster), true);
Assert.AreEqual(monster.TestType, Any.Monster);
//mutate the inventory vector
Assert.AreEqual(monster.MutateInventory(0, 1), true);
Assert.AreEqual(monster.MutateInventory(1, 2), true);
Assert.AreEqual(monster.MutateInventory(2, 3), true);
Assert.AreEqual(monster.MutateInventory(3, 4), true);
Assert.AreEqual(monster.MutateInventory(4, 5), true);
for (int i = 0; i < monster.InventoryLength; i++)
{
Assert.AreEqual(monster.GetInventory(i), i + 1);
}
//reverse mutation
Assert.AreEqual(monster.MutateInventory(0, 0), true);
Assert.AreEqual(monster.MutateInventory(1, 1), true);
Assert.AreEqual(monster.MutateInventory(2, 2), true);
Assert.AreEqual(monster.MutateInventory(3, 3), true);
Assert.AreEqual(monster.MutateInventory(4, 4), true);
// get a struct field and edit one of its fields
Vec3 pos = monster.Pos;
Assert.AreEqual(pos.X, 1.0f);
pos.MutateX(55.0f);
Assert.AreEqual(pos.X, 55.0f);
pos.MutateX(1.0f);
Assert.AreEqual(pos.X, 1.0f);
TestBuffer(fbb.DataBuffer);
}
public static void AddLeftHand(FlatBufferBuilder builder, Offset <types.fbs.HandData> leftHandOffset)
{
builder.AddOffset(2, leftHandOffset.Value, 0);
}
public static void AddReferToA1(FlatBufferBuilder builder, Offset <NamespaceA.TableInFirstNS> referToA1Offset)
{
builder.AddOffset(0, referToA1Offset.Value, 0);
}
public static void AddClips(FlatBufferBuilder builder, VectorOffset clipsOffset)
{
builder.AddOffset(0, clipsOffset.Value, 0);
}
public static void AddCellPartsArray(FlatBufferBuilder builder, VectorOffset cellPartsArrayOffset)
{
builder.AddOffset(1, cellPartsArrayOffset.Value, 0);
}
public static void AddKey(FlatBufferBuilder builder, StringOffset keyOffset)
{
builder.AddOffset(0, keyOffset.Value, 0);
}
public static void AddFvec(FlatBufferBuilder builder, VectorOffset fvecOffset)
{
builder.AddOffset(9, fvecOffset.Value, 0);
}
public static void AddValue(FlatBufferBuilder builder, StringOffset valueOffset)
{
builder.AddOffset(1, valueOffset.Value, 0);
}
public static void AddFooTable(FlatBufferBuilder builder, Offset <NamespaceA.NamespaceB.TableInNestedNS> fooTableOffset)
{
builder.AddOffset(0, fooTableOffset.Value, 0);
}
public static void AddDataAnchorPoints(FlatBufferBuilder builder, Offset <anchorPointsHolder> dataAnchorPointsOffset)
{
builder.AddOffset(4, dataAnchorPointsOffset.Value, 0);
}
public static void AddList(FlatBufferBuilder builder, VectorOffset listOffset)
{
builder.AddOffset(0, listOffset.Value, 0);
}
public static void AddDataMesh(FlatBufferBuilder builder, Offset <mesh> dataMeshOffset)
{
builder.AddOffset(0, dataMeshOffset.Value, 0);
}
public static void AddStringVector(FlatBufferBuilder builder, VectorOffset StringVectorOffset)
{
builder.AddOffset(0, StringVectorOffset.Value, 0);
}
public static void AddDataSkeleton(FlatBufferBuilder builder, Offset <skeleton> dataSkeletonOffset)
{
builder.AddOffset(1, dataSkeletonOffset.Value, 0);
}
public void TestVTableWithEmptyVector()
{
var builder = new FlatBufferBuilder(1);
builder.StartVector(sizeof(byte), 0, 1);
var vecEnd = builder.EndVector();
builder.StartObject(1);
builder.AddOffset(0, vecEnd.Value, 0);
builder.EndObject();
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.Data);
}
public static void AddDataAnimation(FlatBufferBuilder builder, Offset <animation> dataAnimationOffset)
{
builder.AddOffset(2, dataAnimationOffset.Value, 0);
}
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.StartObject(2);
builder.AddOffset(1, vecEnd.Value, 0);
builder.AddShort(0, 55, 0);
builder.EndObject();
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.Data);
}
public static void AddDataUvSwapItem(FlatBufferBuilder builder, Offset <uvSwapItemHolder> dataUvSwapItemOffset)
{
builder.AddOffset(3, dataUvSwapItemOffset.Value, 0);
}
public static void AddId(FlatBufferBuilder builder, StringOffset idOffset)
{
builder.AddOffset(0, idOffset.Value, 0);
}
public static void Add_desc(FlatBufferBuilder builder, StringOffset DescOffset)
{
builder.AddOffset(2, DescOffset.Value, 0);
}
