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.Data); builder.AddByte(1); Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, builder.DataBuffer.Data); builder.AddByte(2); Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 2, 1, 0, 0 }, builder.DataBuffer.Data); builder.EndVector(); Assert.ArrayEqual(new byte[] { 2, 0, 0, 0, 2, 1, 0, 0 }, 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); 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 TestNumbers() { var builder = new FlatBufferBuilder(1); Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.Data); builder.AddBool(true); Assert.ArrayEqual(new byte[] { 1 }, builder.DataBuffer.Data); builder.AddSbyte(-127); Assert.ArrayEqual(new byte[] { 129, 1 }, builder.DataBuffer.Data); builder.AddByte(255); Assert.ArrayEqual(new byte[] { 0, 255, 129, 1 }, builder.DataBuffer.Data); // First pad builder.AddShort(-32222); Assert.ArrayEqual(new byte[] { 0, 0, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.Data); // Second pad builder.AddUshort(0xFEEE); Assert.ArrayEqual(new byte[] { 0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.Data); // 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.Data); // 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.Data); // no pad }
public static void AddUserIndex(FlatBufferBuilder builder, byte userIndex) { builder.AddByte(0, userIndex, 0); }
public void TestTwoFinishTable() { var builder = new FlatBufferBuilder(1); builder.StartObject(2); builder.AddByte(0, 33, 0); builder.AddByte(1, 44, 0); var off0 = builder.EndObject(); builder.Finish(off0); builder.StartObject(3); builder.AddByte(0, 55, 0); builder.AddByte(1, 66, 0); builder.AddByte(2, 77, 0); var off1 = builder.EndObject(); 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.Data); }
public static void AddB(FlatBufferBuilder builder, byte b) { builder.AddByte(3, b, 0); }
public static void AddValueType(FlatBufferBuilder builder, FlatSharpTests.Oracle.Union ValueType) { builder.AddByte(0, (byte)ValueType, 0); }
public static void AddTestType(FlatBufferBuilder builder, Any testType) { builder.AddByte(7, (byte)(testType), 0); }
public static void AddR(FlatBufferBuilder builder, byte r) { builder.AddByte(1, r, 0); }
public static void AddDefaultU8(FlatBufferBuilder builder, byte defaultU8) { builder.AddByte(5, defaultU8, 42); }
public static void AddFooUnionType(FlatBufferBuilder builder, NamespaceA.NamespaceB.UnionInNestedNS fooUnionType) { builder.AddByte(2, (byte)fooUnionType, 0); }
public static void AddJustU8(FlatBufferBuilder builder, byte justU8) { builder.AddByte(3, justU8, 0); }
public static void AddMaybeU8(FlatBufferBuilder builder, byte?maybeU8) { builder.AddByte(4, maybeU8); }
public static void AddPlayersInQueue(FlatBufferBuilder builder, byte playersInQueue) { builder.AddByte(0, playersInQueue, 0); }
private void CanCreateNewFlatBufferFromScratch(bool sizePrefix) { // 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); StringOffset[] names = { fbb.CreateString("Frodo"), fbb.CreateString("Barney"), fbb.CreateString("Wilma") }; Offset <Monster>[] off = new Offset <Monster> [3]; Monster.StartMonster(fbb); Monster.AddName(fbb, names[0]); off[0] = Monster.EndMonster(fbb); Monster.StartMonster(fbb); Monster.AddName(fbb, names[1]); off[1] = Monster.EndMonster(fbb); Monster.StartMonster(fbb); Monster.AddName(fbb, names[2]); off[2] = Monster.EndMonster(fbb); var sortMons = Monster.CreateSortedVectorOfMonster(fbb, off); // 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); Monster.AddTestarrayoftables(fbb, sortMons); var mon = Monster.EndMonster(fbb); if (sizePrefix) { Monster.FinishSizePrefixedMonsterBuffer(fbb, mon); } else { Monster.FinishMonsterBuffer(fbb, mon); } // Dump to output directory so we can inspect later, if needed using (var ms = fbb.DataBuffer.ToMemoryStream(fbb.DataBuffer.Position, fbb.Offset)) { var data = ms.ToArray(); string filename = @"Resources/monsterdata_cstest" + (sizePrefix ? "_sp" : "") + ".mon"; File.WriteAllBytes(filename, data); } // Remove the size prefix if necessary for further testing ByteBuffer dataBuffer = fbb.DataBuffer; if (sizePrefix) { Assert.AreEqual(ByteBufferUtil.GetSizePrefix(dataBuffer) + FlatBufferConstants.SizePrefixLength, dataBuffer.Length - dataBuffer.Position); dataBuffer = ByteBufferUtil.RemoveSizePrefix(dataBuffer); } // Now assert the buffer TestBuffer(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(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); // Accessing a vector of sorted by the key tables Assert.AreEqual(monster.Testarrayoftables(0).Value.Name, "Barney"); Assert.AreEqual(monster.Testarrayoftables(1).Value.Name, "Frodo"); Assert.AreEqual(monster.Testarrayoftables(2).Value.Name, "Wilma"); // Example of searching for a table by the key Assert.IsTrue(monster.TestarrayoftablesByKey("Frodo") != null); Assert.IsTrue(monster.TestarrayoftablesByKey("Barney") != null); Assert.IsTrue(monster.TestarrayoftablesByKey("Wilma") != null); // testType is an existing field and mutating it should succeed Assert.AreEqual(monster.TestType, Any.Monster); Assert.AreEqual(monster.MutateTestType(Any.NONE), true); Assert.AreEqual(monster.TestType, Any.NONE); Assert.AreEqual(monster.MutateTestType(Any.Monster), true); 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.Inventory(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 = (Vec3)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(dataBuffer); }
public static void AddPlayerNumber(FlatBufferBuilder builder, byte playerNumber) { builder.AddByte(1, playerNumber, 0); }
public void TestVTableWithSomeElements() { var builder = new FlatBufferBuilder(1); builder.StartObject(2); builder.AddByte(0, 33, 0); builder.AddShort(1, 66, 0); var off = builder.EndObject(); builder.Finish(off); Assert.ArrayEqual(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 }, builder.DataBuffer.Data); }
public static void AddTestType(FlatBufferBuilder builder, byte testType) { builder.AddByte(7, testType, 0); }
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 AddU8(FlatBufferBuilder builder, byte u8) { builder.AddByte(1, u8, 0); }
public static void AddRange(FlatBufferBuilder builder, byte range) { builder.AddByte(4, range, 0); }
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"); } } } }
public static void AddA(FlatBufferBuilder builder, byte a) { builder.AddByte(0, a, 0); }
public static void AddWeaponType(FlatBufferBuilder builder, CompanyNamespaceWhatever.WeaponClassesOrWhatever weaponType) { builder.AddByte(6, (byte)weaponType, 0); }
public static void AddG(FlatBufferBuilder builder, byte g) { builder.AddByte(2, g, 0); }
public static void AddNumMosaics(FlatBufferBuilder builder, byte numMosaics) { builder.AddByte(9, numMosaics, 0); }
public static void AddDirection(FlatBufferBuilder builder, byte direction) { builder.AddByte(8, direction, 0); }
public static void AddType(FlatBufferBuilder builder, sisyfox.sisycol.SettingType type) { builder.AddByte(0, (byte)type, 0); }
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 AddBodyType(FlatBufferBuilder builder, ReactiveMarkets.PlatformApi.Body bodyType) { builder.AddByte(1, (byte)bodyType, 0); }
public static void AddTeamSize(FlatBufferBuilder builder, byte teamSize) { builder.AddByte(1, teamSize, 0); }
public static void AddDataType(FlatBufferBuilder builder, Datas dataType) { builder.AddByte(3, (byte)dataType, 0); }
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 AddValue(FlatBufferBuilder builder, byte value) { builder.AddByte(1, value, 255); }
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.StartObject(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.EndObject(); // 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"); } } } }
public static void AddEquippedType(FlatBufferBuilder builder, Equipment equippedType) { builder.AddByte(8, (byte)equippedType, 0); }
public static void AddRequestType(FlatBufferBuilder builder, Request requestType) { builder.AddByte(0, (byte)requestType, 0); }
public static void AddOffersCount(FlatBufferBuilder builder, byte offersCount) { builder.AddByte(7, offersCount, 0); }