1 /* 2 * Copyright 2014 Google Inc. All rights reserved. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 using System.IO; 18 using System.Text; 19 using System.Threading; 20 using MyGame.Example; 21 using optional_scalars; 22 using KeywordTest; 23 24 namespace FlatBuffers.Test 25 { 26 [FlatBuffersTestClass] 27 public class FlatBuffersExampleTests 28 { RunTests()29 public void RunTests() 30 { 31 CanCreateNewFlatBufferFromScratch(); 32 CanReadCppGeneratedWireFile(); 33 TestEnums(); 34 } 35 36 [FlatBuffersTestMethod] CanCreateNewFlatBufferFromScratch()37 public void CanCreateNewFlatBufferFromScratch() 38 { 39 CanCreateNewFlatBufferFromScratch(true); 40 CanCreateNewFlatBufferFromScratch(false); 41 } 42 CanCreateNewFlatBufferFromScratch(bool sizePrefix)43 private void CanCreateNewFlatBufferFromScratch(bool sizePrefix) 44 { 45 // Second, let's create a FlatBuffer from scratch in C#, and test it also. 46 // We use an initial size of 1 to exercise the reallocation algorithm, 47 // normally a size larger than the typical FlatBuffer you generate would be 48 // better for performance. 49 var fbb = new FlatBufferBuilder(1); 50 51 StringOffset[] names = { fbb.CreateString("Frodo"), fbb.CreateString("Barney"), fbb.CreateString("Wilma") }; 52 Offset<Monster>[] off = new Offset<Monster>[3]; 53 Monster.StartMonster(fbb); 54 Monster.AddName(fbb, names[0]); 55 off[0] = Monster.EndMonster(fbb); 56 Monster.StartMonster(fbb); 57 Monster.AddName(fbb, names[1]); 58 off[1] = Monster.EndMonster(fbb); 59 Monster.StartMonster(fbb); 60 Monster.AddName(fbb, names[2]); 61 off[2] = Monster.EndMonster(fbb); 62 var sortMons = Monster.CreateSortedVectorOfMonster(fbb, off); 63 64 // We set up the same values as monsterdata.json: 65 66 var str = fbb.CreateString("MyMonster"); 67 var test1 = fbb.CreateString("test1"); 68 var test2 = fbb.CreateString("test2"); 69 70 71 Monster.StartInventoryVector(fbb, 5); 72 for (int i = 4; i >= 0; i--) 73 { 74 fbb.AddByte((byte)i); 75 } 76 var inv = fbb.EndVector(); 77 78 var fred = fbb.CreateString("Fred"); 79 Monster.StartMonster(fbb); 80 Monster.AddName(fbb, fred); 81 var mon2 = Monster.EndMonster(fbb); 82 83 Monster.StartTest4Vector(fbb, 2); 84 MyGame.Example.Test.CreateTest(fbb, (short)10, (sbyte)20); 85 MyGame.Example.Test.CreateTest(fbb, (short)30, (sbyte)40); 86 var test4 = fbb.EndVector(); 87 88 Monster.StartTestarrayofstringVector(fbb, 2); 89 fbb.AddOffset(test2.Value); 90 fbb.AddOffset(test1.Value); 91 var testArrayOfString = fbb.EndVector(); 92 93 Monster.StartMonster(fbb); 94 Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0, 95 Color.Green, (short)5, (sbyte)6)); 96 Monster.AddHp(fbb, (short)80); 97 Monster.AddName(fbb, str); 98 Monster.AddInventory(fbb, inv); 99 Monster.AddTestType(fbb, Any.Monster); 100 Monster.AddTest(fbb, mon2.Value); 101 Monster.AddTest4(fbb, test4); 102 Monster.AddTestarrayofstring(fbb, testArrayOfString); 103 Monster.AddTestbool(fbb, true); 104 Monster.AddTestarrayoftables(fbb, sortMons); 105 var mon = Monster.EndMonster(fbb); 106 107 if (sizePrefix) 108 { 109 Monster.FinishSizePrefixedMonsterBuffer(fbb, mon); 110 } 111 else 112 { 113 Monster.FinishMonsterBuffer(fbb, mon); 114 } 115 116 // Dump to output directory so we can inspect later, if needed 117 #if ENABLE_SPAN_T 118 var data = fbb.DataBuffer.ToSizedArray(); 119 string filename = @"monsterdata_cstest" + (sizePrefix ? "_sp" : "") + ".mon"; 120 File.WriteAllBytes(filename, data); 121 #else 122 using (var ms = fbb.DataBuffer.ToMemoryStream(fbb.DataBuffer.Position, fbb.Offset)) 123 { 124 var data = ms.ToArray(); 125 string filename = @"monsterdata_cstest" + (sizePrefix ? "_sp" : "") + ".mon"; 126 File.WriteAllBytes(filename, data); 127 } 128 #endif 129 130 // Remove the size prefix if necessary for further testing 131 ByteBuffer dataBuffer = fbb.DataBuffer; 132 if (sizePrefix) 133 { 134 Assert.AreEqual(ByteBufferUtil.GetSizePrefix(dataBuffer) + FlatBufferConstants.SizePrefixLength, 135 dataBuffer.Length - dataBuffer.Position); 136 dataBuffer = ByteBufferUtil.RemoveSizePrefix(dataBuffer); 137 } 138 139 // Now assert the buffer 140 TestBuffer(dataBuffer); 141 142 //Attempt to mutate Monster fields and check whether the buffer has been mutated properly 143 // revert to original values after testing 144 Monster monster = Monster.GetRootAsMonster(dataBuffer); 145 146 147 // mana is optional and does not exist in the buffer so the mutation should fail 148 // the mana field should retain its default value 149 Assert.AreEqual(monster.MutateMana((short)10), false); 150 Assert.AreEqual(monster.Mana, (short)150); 151 152 // Accessing a vector of sorted by the key tables 153 Assert.AreEqual(monster.Testarrayoftables(0).Value.Name, "Barney"); 154 Assert.AreEqual(monster.Testarrayoftables(1).Value.Name, "Frodo"); 155 Assert.AreEqual(monster.Testarrayoftables(2).Value.Name, "Wilma"); 156 157 // Example of searching for a table by the key 158 Assert.IsTrue(monster.TestarrayoftablesByKey("Frodo") != null); 159 Assert.AreEqual(monster.TestarrayoftablesByKey("Frodo").Value.Name, "Frodo"); 160 Assert.IsTrue(monster.TestarrayoftablesByKey("Barney") != null); 161 Assert.AreEqual(monster.TestarrayoftablesByKey("Barney").Value.Name, "Barney"); 162 Assert.IsTrue(monster.TestarrayoftablesByKey("Wilma") != null); 163 Assert.AreEqual(monster.TestarrayoftablesByKey("Wilma").Value.Name, "Wilma"); 164 165 // testType is an existing field 166 Assert.AreEqual(monster.TestType, Any.Monster); 167 168 //mutate the inventory vector 169 Assert.AreEqual(monster.MutateInventory(0, 1), true); 170 Assert.AreEqual(monster.MutateInventory(1, 2), true); 171 Assert.AreEqual(monster.MutateInventory(2, 3), true); 172 Assert.AreEqual(monster.MutateInventory(3, 4), true); 173 Assert.AreEqual(monster.MutateInventory(4, 5), true); 174 175 for (int i = 0; i < monster.InventoryLength; i++) 176 { 177 Assert.AreEqual(monster.Inventory(i), i + 1); 178 } 179 180 //reverse mutation 181 Assert.AreEqual(monster.MutateInventory(0, 0), true); 182 Assert.AreEqual(monster.MutateInventory(1, 1), true); 183 Assert.AreEqual(monster.MutateInventory(2, 2), true); 184 Assert.AreEqual(monster.MutateInventory(3, 3), true); 185 Assert.AreEqual(monster.MutateInventory(4, 4), true); 186 187 // get a struct field and edit one of its fields 188 Vec3 pos = (Vec3)monster.Pos; 189 Assert.AreEqual(pos.X, 1.0f); 190 pos.MutateX(55.0f); 191 Assert.AreEqual(pos.X, 55.0f); 192 pos.MutateX(1.0f); 193 Assert.AreEqual(pos.X, 1.0f); 194 195 TestBuffer(dataBuffer); 196 TestObjectAPI(Monster.GetRootAsMonster(dataBuffer)); 197 } 198 TestBuffer(ByteBuffer bb)199 private void TestBuffer(ByteBuffer bb) 200 { 201 Monster monster = Monster.GetRootAsMonster(bb); 202 203 Assert.AreEqual(80, monster.Hp); 204 Assert.AreEqual(150, monster.Mana); 205 Assert.AreEqual("MyMonster", monster.Name); 206 207 var pos = monster.Pos.Value; 208 Assert.AreEqual(1.0f, pos.X); 209 Assert.AreEqual(2.0f, pos.Y); 210 Assert.AreEqual(3.0f, pos.Z); 211 212 Assert.AreEqual(3.0f, pos.Test1); 213 Assert.AreEqual(Color.Green, pos.Test2); 214 var t = (MyGame.Example.Test)pos.Test3; 215 Assert.AreEqual((short)5, t.A); 216 Assert.AreEqual((sbyte)6, t.B); 217 218 Assert.AreEqual(Any.Monster, monster.TestType); 219 220 var monster2 = monster.Test<Monster>().Value; 221 Assert.AreEqual("Fred", monster2.Name); 222 223 224 Assert.AreEqual(5, monster.InventoryLength); 225 var invsum = 0; 226 for (var i = 0; i < monster.InventoryLength; i++) 227 { 228 invsum += monster.Inventory(i); 229 } 230 Assert.AreEqual(10, invsum); 231 232 // Get the inventory as an array and subtract the 233 // sum to get it back to 0 234 var inventoryArray = monster.GetInventoryArray(); 235 Assert.AreEqual(5, inventoryArray.Length); 236 foreach(var inv in inventoryArray) 237 { 238 invsum -= inv; 239 } 240 Assert.AreEqual(0, invsum); 241 242 var test0 = monster.Test4(0).Value; 243 var test1 = monster.Test4(1).Value; 244 Assert.AreEqual(2, monster.Test4Length); 245 246 Assert.AreEqual(100, test0.A + test0.B + test1.A + test1.B); 247 248 Assert.AreEqual(2, monster.TestarrayofstringLength); 249 Assert.AreEqual("test1", monster.Testarrayofstring(0)); 250 Assert.AreEqual("test2", monster.Testarrayofstring(1)); 251 252 Assert.AreEqual(true, monster.Testbool); 253 254 #if ENABLE_SPAN_T 255 var nameBytes = monster.GetNameBytes(); 256 Assert.AreEqual("MyMonster", Encoding.UTF8.GetString(nameBytes.ToArray(), 0, nameBytes.Length)); 257 258 if (0 == monster.TestarrayofboolsLength) 259 { 260 Assert.IsFalse(monster.GetTestarrayofboolsBytes().Length != 0); 261 } 262 else 263 { 264 Assert.IsTrue(monster.GetTestarrayofboolsBytes().Length != 0); 265 } 266 267 var longArrayBytes = monster.GetVectorOfLongsBytes(); 268 Assert.IsTrue(monster.VectorOfLongsLength * 8 == longArrayBytes.Length); 269 270 var doubleArrayBytes = monster.GetVectorOfDoublesBytes(); 271 Assert.IsTrue(monster.VectorOfDoublesLength * 8 == doubleArrayBytes.Length); 272 #else 273 var nameBytes = monster.GetNameBytes().Value; 274 Assert.AreEqual("MyMonster", Encoding.UTF8.GetString(nameBytes.Array, nameBytes.Offset, nameBytes.Count)); 275 276 if (0 == monster.TestarrayofboolsLength) 277 { 278 Assert.IsFalse(monster.GetTestarrayofboolsBytes().HasValue); 279 } 280 else 281 { 282 Assert.IsTrue(monster.GetTestarrayofboolsBytes().HasValue); 283 } 284 #endif 285 } 286 287 [FlatBuffersTestMethod] CanReadCppGeneratedWireFile()288 public void CanReadCppGeneratedWireFile() 289 { 290 var data = File.ReadAllBytes(@"../monsterdata_test.mon"); 291 var bb = new ByteBuffer(data); 292 TestBuffer(bb); 293 TestObjectAPI(Monster.GetRootAsMonster(bb)); 294 } 295 296 [FlatBuffersTestMethod] CanReadJsonFile()297 public void CanReadJsonFile() 298 { 299 var jsonText = File.ReadAllText(@"../monsterdata_test.json"); 300 var mon = MonsterT.DeserializeFromJson(jsonText); 301 var fbb = new FlatBufferBuilder(1); 302 fbb.Finish(Monster.Pack(fbb, mon).Value); 303 TestBuffer(fbb.DataBuffer); 304 } 305 306 [FlatBuffersTestMethod] TestEnums()307 public void TestEnums() 308 { 309 Assert.AreEqual("Red", Color.Red.ToString()); 310 Assert.AreEqual("Blue", Color.Blue.ToString()); 311 Assert.AreEqual("NONE", Any.NONE.ToString()); 312 Assert.AreEqual("Monster", Any.Monster.ToString()); 313 } 314 315 [FlatBuffersTestMethod] TestVectorOfEnums()316 public void TestVectorOfEnums() 317 { 318 const string monsterName = "TestVectorOfEnumsMonster"; 319 var colorVec = new Color[] { Color.Red, Color.Green, Color.Blue }; 320 var fbb = new FlatBufferBuilder(32); 321 var str1 = fbb.CreateString(monsterName); 322 var vec1 = Monster.CreateVectorOfEnumsVector(fbb, colorVec); 323 Monster.StartMonster(fbb); 324 Monster.AddName(fbb, str1); 325 Monster.AddVectorOfEnums(fbb, vec1); 326 var monster1 = Monster.EndMonster(fbb); 327 Monster.FinishMonsterBuffer(fbb, monster1); 328 329 var mons = Monster.GetRootAsMonster(fbb.DataBuffer); 330 var colors = mons.GetVectorOfEnumsArray(); 331 Assert.ArrayEqual(colorVec, colors); 332 333 TestObjectAPI(mons); 334 } 335 336 [FlatBuffersTestMethod] TestNestedFlatBuffer()337 public void TestNestedFlatBuffer() 338 { 339 const string nestedMonsterName = "NestedMonsterName"; 340 const short nestedMonsterHp = 600; 341 const short nestedMonsterMana = 1024; 342 // Create nested buffer as a Monster type 343 var fbb1 = new FlatBufferBuilder(16); 344 var str1 = fbb1.CreateString(nestedMonsterName); 345 Monster.StartMonster(fbb1); 346 Monster.AddName(fbb1, str1); 347 Monster.AddHp(fbb1, nestedMonsterHp); 348 Monster.AddMana(fbb1, nestedMonsterMana); 349 var monster1 = Monster.EndMonster(fbb1); 350 Monster.FinishMonsterBuffer(fbb1, monster1); 351 var fbb1Bytes = fbb1.SizedByteArray(); 352 fbb1 = null; 353 354 // Create a Monster which has the first buffer as a nested buffer 355 var fbb2 = new FlatBufferBuilder(16); 356 var str2 = fbb2.CreateString("My Monster"); 357 var nestedBuffer = Monster.CreateTestnestedflatbufferVector(fbb2, fbb1Bytes); 358 Monster.StartMonster(fbb2); 359 Monster.AddName(fbb2, str2); 360 Monster.AddHp(fbb2, 50); 361 Monster.AddMana(fbb2, 32); 362 Monster.AddTestnestedflatbuffer(fbb2, nestedBuffer); 363 var monster = Monster.EndMonster(fbb2); 364 Monster.FinishMonsterBuffer(fbb2, monster); 365 366 // Now test the data extracted from the nested buffer 367 var mons = Monster.GetRootAsMonster(fbb2.DataBuffer); 368 var nestedMonster = mons.GetTestnestedflatbufferAsMonster().Value; 369 370 Assert.AreEqual(nestedMonsterMana, nestedMonster.Mana); 371 Assert.AreEqual(nestedMonsterHp, nestedMonster.Hp); 372 Assert.AreEqual(nestedMonsterName, nestedMonster.Name); 373 374 TestObjectAPI(mons); 375 TestObjectAPI(nestedMonster); 376 } 377 378 [FlatBuffersTestMethod] TestFixedLenghtArrays()379 public void TestFixedLenghtArrays() 380 { 381 FlatBufferBuilder builder = new FlatBufferBuilder(100); 382 383 float a; 384 int[] b = new int[15]; 385 sbyte c; 386 int[,] d_a = new int[2, 2]; 387 TestEnum[] d_b = new TestEnum[2]; 388 TestEnum[,] d_c = new TestEnum[2, 2]; 389 long[,] d_d = new long[2, 2]; 390 int e; 391 long[] f = new long[2]; 392 393 a = 0.5f; 394 for (int i = 0; i < 15; i++) b[i] = i; 395 c = 1; 396 d_a[0, 0] = 1; 397 d_a[0, 1] = 2; 398 d_a[1, 0] = 3; 399 d_a[1, 1] = 4; 400 d_b[0] = TestEnum.B; 401 d_b[1] = TestEnum.C; 402 d_c[0, 0] = TestEnum.A; 403 d_c[0, 1] = TestEnum.B; 404 d_c[1, 0] = TestEnum.C; 405 d_c[1, 1] = TestEnum.B; 406 d_d[0, 0] = -1; 407 d_d[0, 1] = 1; 408 d_d[1, 0] = -2; 409 d_d[1, 1] = 2; 410 e = 2; 411 f[0] = -1; 412 f[1] = 1; 413 414 Offset<ArrayStruct> arrayOffset = ArrayStruct.CreateArrayStruct( 415 builder, a, b, c, d_a, d_b, d_c, d_d, e, f); 416 417 // Create a table with the ArrayStruct. 418 ArrayTable.StartArrayTable(builder); 419 ArrayTable.AddA(builder, arrayOffset); 420 Offset<ArrayTable> tableOffset = ArrayTable.EndArrayTable(builder); 421 422 ArrayTable.FinishArrayTableBuffer(builder, tableOffset); 423 424 ArrayTable table = ArrayTable.GetRootAsArrayTable(builder.DataBuffer); 425 426 Assert.AreEqual(table.A.Value.A, 0.5f); 427 for (int i = 0; i < 15; i++) Assert.AreEqual(table.A.Value.B(i), i); 428 Assert.AreEqual(table.A.Value.C, (sbyte)1); 429 Assert.AreEqual(table.A.Value.D(0).A(0), 1); 430 Assert.AreEqual(table.A.Value.D(0).A(1), 2); 431 Assert.AreEqual(table.A.Value.D(1).A(0), 3); 432 Assert.AreEqual(table.A.Value.D(1).A(1), 4); 433 Assert.AreEqual(table.A.Value.D(0).B, TestEnum.B); 434 Assert.AreEqual(table.A.Value.D(1).B, TestEnum.C); 435 Assert.AreEqual(table.A.Value.D(0).C(0), TestEnum.A); 436 Assert.AreEqual(table.A.Value.D(0).C(1), TestEnum.B); 437 Assert.AreEqual(table.A.Value.D(1).C(0), TestEnum.C); 438 Assert.AreEqual(table.A.Value.D(1).C(1), TestEnum.B); 439 Assert.AreEqual(table.A.Value.D(0).D(0), -1); 440 Assert.AreEqual(table.A.Value.D(0).D(1), 1); 441 Assert.AreEqual(table.A.Value.D(1).D(0), -2); 442 Assert.AreEqual(table.A.Value.D(1).D(1), 2); 443 Assert.AreEqual(table.A.Value.E, 2); 444 Assert.AreEqual(table.A.Value.F(0), -1); 445 Assert.AreEqual(table.A.Value.F(1), 1); 446 447 TestObjectAPI(table); 448 } 449 450 [FlatBuffersTestMethod] TestUnionVector()451 public void TestUnionVector() 452 { 453 var fbb = new FlatBufferBuilder(100); 454 var rapunzel = Rapunzel.CreateRapunzel(fbb, 40).Value; 455 456 var characterTypes = new[] 457 { 458 Character.MuLan, 459 Character.Belle, 460 Character.Other, 461 }; 462 var characterTypesOffset = Movie.CreateCharactersTypeVector(fbb, characterTypes); 463 464 var characters = new[] 465 { 466 Attacker.CreateAttacker(fbb, 10).Value, 467 BookReader.CreateBookReader(fbb, 20).Value, 468 fbb.CreateSharedString("Chip").Value, 469 }; 470 var charactersOffset = Movie.CreateCharactersVector(fbb, characters); 471 472 var movieOffset = Movie.CreateMovie( 473 fbb, 474 Character.Rapunzel, 475 rapunzel, 476 characterTypesOffset, 477 charactersOffset); 478 Movie.FinishMovieBuffer(fbb, movieOffset); 479 480 var movie = Movie.GetRootAsMovie(fbb.DataBuffer); 481 Assert.AreEqual(Character.Rapunzel, movie.MainCharacterType); 482 Assert.AreEqual(40, movie.MainCharacter<Rapunzel>().Value.HairLength); 483 484 Assert.AreEqual(3, movie.CharactersLength); 485 Assert.AreEqual(Character.MuLan, movie.CharactersType(0)); 486 Assert.AreEqual(10, movie.Characters<Attacker>(0).Value.SwordAttackDamage); 487 Assert.AreEqual(Character.Belle, movie.CharactersType(1)); 488 Assert.AreEqual(20, movie.Characters<BookReader>(1).Value.BooksRead); 489 Assert.AreEqual(Character.Other, movie.CharactersType(2)); 490 Assert.AreEqual("Chip", movie.CharactersAsString(2)); 491 492 TestObjectAPI(movie); 493 } 494 495 [FlatBuffersTestMethod] TestUnionUtility()496 public void TestUnionUtility() 497 { 498 var movie = new MovieT 499 { 500 MainCharacter = CharacterUnion.FromRapunzel(new RapunzelT { HairLength = 40 }), 501 Characters = new System.Collections.Generic.List<CharacterUnion> 502 { 503 CharacterUnion.FromMuLan(new AttackerT { SwordAttackDamage = 10 }), 504 CharacterUnion.FromBelle(new BookReaderT { BooksRead = 20 }), 505 CharacterUnion.FromOther("Chip"), 506 }, 507 }; 508 509 var fbb = new FlatBufferBuilder(100); 510 Movie.FinishMovieBuffer(fbb, Movie.Pack(fbb, movie)); 511 512 TestObjectAPI(Movie.GetRootAsMovie(fbb.DataBuffer)); 513 } 514 AreEqual(Monster a, MonsterT b)515 private void AreEqual(Monster a, MonsterT b) 516 { 517 Assert.AreEqual(a.Hp, b.Hp); 518 Assert.AreEqual(a.Mana, b.Mana); 519 Assert.AreEqual(a.Name, b.Name); 520 521 var posA = a.Pos; 522 var posB = b.Pos; 523 if (posA != null) 524 { 525 Assert.AreEqual(posA.Value.X, posB.X); 526 Assert.AreEqual(posA.Value.Y, posB.Y); 527 Assert.AreEqual(posA.Value.Z, posB.Z); 528 529 Assert.AreEqual(posA.Value.Test1, posB.Test1); 530 Assert.AreEqual(posA.Value.Test2, posB.Test2); 531 var tA = posA.Value.Test3; 532 var tB = posB.Test3; 533 Assert.AreEqual(tA.A, tB.A); 534 Assert.AreEqual(tA.B, tB.B); 535 } 536 537 Assert.AreEqual(a.TestType, b.Test.Type); 538 if (a.TestType == Any.Monster) 539 { 540 var monster2A = a.Test<Monster>().Value; 541 var monster2B = b.Test.AsMonster(); 542 Assert.AreEqual(monster2A.Name, monster2B.Name); 543 } 544 545 Assert.AreEqual(a.InventoryLength, b.Inventory.Count); 546 for (var i = 0; i < a.InventoryLength; ++i) 547 { 548 Assert.AreEqual(a.Inventory(i), b.Inventory[i]); 549 } 550 551 var inventoryArray = a.GetInventoryArray(); 552 var inventoryArrayLength = inventoryArray == null ? 0 : inventoryArray.Length; 553 Assert.AreEqual(inventoryArrayLength, b.Inventory.Count); 554 for (var i = 0; i < inventoryArrayLength; ++i) 555 { 556 Assert.AreEqual(inventoryArray[i], b.Inventory[i]); 557 } 558 559 Assert.AreEqual(a.Test4Length, b.Test4.Count); 560 for (var i = 0; i < a.Test4Length; ++i) 561 { 562 var t4A = a.Test4(i); 563 var t4B = b.Test4[i]; 564 Assert.AreEqual(t4A.Value.A, t4B.A); 565 Assert.AreEqual(t4A.Value.B, t4B.B); 566 } 567 568 Assert.AreEqual(a.TestarrayofstringLength, b.Testarrayofstring.Count); 569 for (var i = 0; i < a.TestarrayofstringLength; ++i) 570 { 571 Assert.AreEqual(a.Testarrayofstring(i), b.Testarrayofstring[i]); 572 } 573 574 Assert.AreEqual(a.Testbool, b.Testbool); 575 576 Assert.AreEqual(a.TestarrayofboolsLength, b.Testarrayofbools.Count); 577 for (var i = 0; i < a.TestarrayofboolsLength; ++i) 578 { 579 Assert.AreEqual(a.Testarrayofbools(i), b.Testarrayofbools[i]); 580 } 581 582 Assert.AreEqual(a.VectorOfLongsLength, b.VectorOfLongs.Count); 583 for (var i = 0; i < a.VectorOfLongsLength; ++i) 584 { 585 Assert.AreEqual(a.VectorOfLongs(i), b.VectorOfLongs[i]); 586 } 587 588 Assert.AreEqual(a.VectorOfDoublesLength, b.VectorOfDoubles.Count); 589 for (var i = 0; i < a.VectorOfDoublesLength; ++i) 590 { 591 Assert.AreEqual(a.VectorOfDoubles(i), b.VectorOfDoubles[i]); 592 } 593 594 Assert.AreEqual(a.VectorOfEnumsLength, b.VectorOfEnums.Count); 595 for (var i = 0; i < a.VectorOfEnumsLength; ++i) 596 { 597 Assert.AreEqual(a.VectorOfEnums(i), b.VectorOfEnums[i]); 598 } 599 } 600 AreEqual(Monster a, Monster b)601 private void AreEqual(Monster a, Monster b) 602 { 603 Assert.AreEqual(a.Hp, b.Hp); 604 Assert.AreEqual(a.Mana, b.Mana); 605 Assert.AreEqual(a.Name, b.Name); 606 607 var posA = a.Pos; 608 var posB = b.Pos; 609 if (posA != null) 610 { 611 Assert.AreEqual(posA.Value.X, posB.Value.X); 612 Assert.AreEqual(posA.Value.Y, posB.Value.Y); 613 Assert.AreEqual(posA.Value.Z, posB.Value.Z); 614 615 Assert.AreEqual(posA.Value.Test1, posB.Value.Test1); 616 Assert.AreEqual(posA.Value.Test2, posB.Value.Test2); 617 var tA = posA.Value.Test3; 618 var tB = posB.Value.Test3; 619 Assert.AreEqual(tA.A, tB.A); 620 Assert.AreEqual(tA.B, tB.B); 621 } 622 623 Assert.AreEqual(a.TestType, b.TestType); 624 if (a.TestType == Any.Monster) 625 { 626 var monster2A = a.Test<Monster>().Value; 627 var monster2B = b.Test<Monster>().Value; 628 Assert.AreEqual(monster2A.Name, monster2B.Name); 629 } 630 631 Assert.AreEqual(a.InventoryLength, b.InventoryLength); 632 for (var i = 0; i < a.InventoryLength; ++i) 633 { 634 Assert.AreEqual(a.Inventory(i), b.Inventory(i)); 635 } 636 637 var inventoryArrayA = a.GetInventoryArray(); 638 var inventoryArrayALength = inventoryArrayA == null ? 0 : inventoryArrayA.Length; 639 var inventoryArrayB = b.GetInventoryArray(); 640 var inventoryArrayBLength = inventoryArrayB == null ? 0 : inventoryArrayB.Length; 641 Assert.AreEqual(inventoryArrayALength, inventoryArrayBLength); 642 for (var i = 0; i < inventoryArrayALength; ++i) 643 { 644 Assert.AreEqual(inventoryArrayA[i], inventoryArrayB[i]); 645 } 646 647 Assert.AreEqual(a.Test4Length, b.Test4Length); 648 for (var i = 0; i < a.Test4Length; ++i) 649 { 650 var t4A = a.Test4(i); 651 var t4B = b.Test4(i); 652 Assert.AreEqual(t4A.Value.A, t4B.Value.A); 653 Assert.AreEqual(t4A.Value.B, t4B.Value.B); 654 } 655 656 Assert.AreEqual(a.TestarrayofstringLength, b.TestarrayofstringLength); 657 for (var i = 0; i < a.TestarrayofstringLength; ++i) 658 { 659 Assert.AreEqual(a.Testarrayofstring(i), b.Testarrayofstring(i)); 660 } 661 662 Assert.AreEqual(a.Testbool, b.Testbool); 663 664 Assert.AreEqual(a.TestarrayofboolsLength, b.TestarrayofboolsLength); 665 for (var i = 0; i < a.TestarrayofboolsLength; ++i) 666 { 667 Assert.AreEqual(a.Testarrayofbools(i), b.Testarrayofbools(i)); 668 } 669 670 Assert.AreEqual(a.VectorOfLongsLength, b.VectorOfLongsLength); 671 for (var i = 0; i < a.VectorOfLongsLength; ++i) 672 { 673 Assert.AreEqual(a.VectorOfLongs(i), b.VectorOfLongs(i)); 674 } 675 676 Assert.AreEqual(a.VectorOfDoublesLength, b.VectorOfDoublesLength); 677 for (var i = 0; i < a.VectorOfDoublesLength; ++i) 678 { 679 Assert.AreEqual(a.VectorOfDoubles(i), b.VectorOfDoubles(i)); 680 } 681 682 Assert.AreEqual(a.VectorOfEnumsLength, b.VectorOfEnumsLength); 683 for (var i = 0; i < a.VectorOfEnumsLength; ++i) 684 { 685 Assert.AreEqual(a.VectorOfEnums(i), b.VectorOfEnums(i)); 686 } 687 } 688 TestObjectAPI(Monster a)689 private void TestObjectAPI(Monster a) 690 { 691 var b = a.UnPack(); 692 AreEqual(a, b); 693 694 var fbb = new FlatBufferBuilder(1); 695 fbb.Finish(Monster.Pack(fbb, b).Value); 696 var c = Monster.GetRootAsMonster(fbb.DataBuffer); 697 AreEqual(a, c); 698 699 var jsonText = b.SerializeToJson(); 700 var d = MonsterT.DeserializeFromJson(jsonText); 701 AreEqual(a, d); 702 703 var fbBuffer = b.SerializeToBinary(); 704 Assert.IsTrue(Monster.MonsterBufferHasIdentifier(new ByteBuffer(fbBuffer))); 705 var e = MonsterT.DeserializeFromBinary(fbBuffer); 706 AreEqual(a, e); 707 } 708 AreEqual(ArrayTable a, ArrayTableT b)709 private void AreEqual(ArrayTable a, ArrayTableT b) 710 { 711 Assert.AreEqual(a.A.Value.A, b.A.A); 712 713 for (int i = 0; i < 15; ++i) 714 { 715 Assert.AreEqual(a.A.Value.B(i), b.A.B[i]); 716 } 717 718 Assert.AreEqual(a.A.Value.C, b.A.C); 719 720 for (int i = 0; i < 2; ++i) 721 { 722 var ad = a.A.Value.D(i); 723 var bd = b.A.D[i]; 724 725 for (int j = 0; j < 2; ++j) 726 { 727 Assert.AreEqual(ad.A(j), bd.A[j]); 728 } 729 730 Assert.AreEqual(ad.B, bd.B); 731 732 for (int j = 0; j < 2; ++j) 733 { 734 Assert.AreEqual(ad.C(j), bd.C[j]); 735 } 736 737 for (int j = 0; j < 2; ++j) 738 { 739 Assert.AreEqual(ad.D(j), bd.D[j]); 740 } 741 } 742 743 Assert.AreEqual(a.A.Value.E, b.A.E); 744 745 for (int i = 0; i < 2; ++i) 746 { 747 Assert.AreEqual(a.A.Value.F(i), b.A.F[i]); 748 } 749 } 750 AreEqual(ArrayTable a, ArrayTable b)751 private void AreEqual(ArrayTable a, ArrayTable b) 752 { 753 Assert.AreEqual(a.A.Value.A, b.A.Value.A); 754 755 for (int i = 0; i < 15; ++i) 756 { 757 Assert.AreEqual(a.A.Value.B(i), b.A.Value.B(i)); 758 } 759 760 Assert.AreEqual(a.A.Value.C, b.A.Value.C); 761 762 for (int i = 0; i < 2; ++i) 763 { 764 var ad = a.A.Value.D(i); 765 var bd = b.A.Value.D(i); 766 767 for (int j = 0; j < 2; ++j) 768 { 769 Assert.AreEqual(ad.A(j), bd.A(j)); 770 } 771 772 Assert.AreEqual(ad.B, bd.B); 773 774 for (int j = 0; j < 2; ++j) 775 { 776 Assert.AreEqual(ad.C(j), bd.C(j)); 777 } 778 779 for (int j = 0; j < 2; ++j) 780 { 781 Assert.AreEqual(ad.D(j), bd.D(j)); 782 } 783 } 784 785 Assert.AreEqual(a.A.Value.E, b.A.Value.E); 786 787 for (int i = 0; i < 2; ++i) 788 { 789 Assert.AreEqual(a.A.Value.F(i), b.A.Value.F(i)); 790 } 791 } 792 TestObjectAPI(ArrayTable a)793 private void TestObjectAPI(ArrayTable a) 794 { 795 var b = a.UnPack(); 796 AreEqual(a, b); 797 798 var fbb = new FlatBufferBuilder(1); 799 fbb.Finish(ArrayTable.Pack(fbb, b).Value); 800 var c = ArrayTable.GetRootAsArrayTable(fbb.DataBuffer); 801 AreEqual(a, c); 802 803 var jsonText = b.SerializeToJson(); 804 var d = ArrayTableT.DeserializeFromJson(jsonText); 805 AreEqual(a, d); 806 807 var fbBuffer = b.SerializeToBinary(); 808 Assert.IsTrue(ArrayTable.ArrayTableBufferHasIdentifier(new ByteBuffer(fbBuffer))); 809 var e = ArrayTableT.DeserializeFromBinary(fbBuffer); 810 AreEqual(a, e); 811 } 812 AreEqual(Movie a, MovieT b)813 private void AreEqual(Movie a, MovieT b) 814 { 815 Assert.AreEqual(a.MainCharacterType, b.MainCharacter.Type); 816 Assert.AreEqual(a.MainCharacter<Rapunzel>().Value.HairLength, b.MainCharacter.AsRapunzel().HairLength); 817 818 Assert.AreEqual(a.CharactersLength, b.Characters.Count); 819 Assert.AreEqual(a.CharactersType(0), b.Characters[0].Type); 820 Assert.AreEqual(a.Characters<Attacker>(0).Value.SwordAttackDamage, b.Characters[0].AsMuLan().SwordAttackDamage); 821 Assert.AreEqual(a.CharactersType(1), b.Characters[1].Type); 822 Assert.AreEqual(a.Characters<BookReader>(1).Value.BooksRead, b.Characters[1].AsBelle().BooksRead); 823 Assert.AreEqual(a.CharactersType(2), b.Characters[2].Type); 824 Assert.AreEqual(a.CharactersAsString(2), b.Characters[2].AsOther()); 825 } 826 AreEqual(Movie a, Movie b)827 private void AreEqual(Movie a, Movie b) 828 { 829 Assert.AreEqual(a.MainCharacterType, b.MainCharacterType); 830 Assert.AreEqual(a.MainCharacter<Rapunzel>().Value.HairLength, b.MainCharacter<Rapunzel>().Value.HairLength); 831 832 Assert.AreEqual(a.CharactersLength, b.CharactersLength); 833 Assert.AreEqual(a.CharactersType(0), b.CharactersType(0)); 834 Assert.AreEqual(a.Characters<Attacker>(0).Value.SwordAttackDamage, b.Characters<Attacker>(0).Value.SwordAttackDamage); 835 Assert.AreEqual(a.CharactersType(1), b.CharactersType(1)); 836 Assert.AreEqual(a.Characters<BookReader>(1).Value.BooksRead, b.Characters<BookReader>(1).Value.BooksRead); 837 Assert.AreEqual(a.CharactersType(2), b.CharactersType(2)); 838 Assert.AreEqual(a.CharactersAsString(2), b.CharactersAsString(2)); 839 } 840 TestObjectAPI(Movie a)841 private void TestObjectAPI(Movie a) 842 { 843 var b = a.UnPack(); 844 AreEqual(a, b); 845 846 var fbb = new FlatBufferBuilder(1); 847 fbb.Finish(Movie.Pack(fbb, b).Value); 848 var c = Movie.GetRootAsMovie(fbb.DataBuffer); 849 AreEqual(a, c); 850 851 var jsonText = b.SerializeToJson(); 852 var d = MovieT.DeserializeFromJson(jsonText); 853 AreEqual(a, d); 854 855 var fbBuffer = b.SerializeToBinary(); 856 Assert.IsTrue(Movie.MovieBufferHasIdentifier(new ByteBuffer(fbBuffer))); 857 var e = MovieT.DeserializeFromBinary(fbBuffer); 858 AreEqual(a, e); 859 } 860 861 // For use in TestParallelAccess test case. 862 static private int _comparisons = 0; 863 static private int _failures = 0; KeepComparing(Monster mon, int count, float floatValue, double doubleValue)864 static private void KeepComparing(Monster mon, int count, float floatValue, double doubleValue) 865 { 866 int i = 0; 867 while (++i <= count) 868 { 869 Interlocked.Add(ref _comparisons, 1); 870 if(mon.Pos.Value.Test1 != doubleValue || mon.Pos.Value.Z != floatValue) { 871 Interlocked.Add(ref _failures, 1); 872 } 873 } 874 } 875 876 [FlatBuffersTestMethod] TestParallelAccess()877 public void TestParallelAccess() { 878 // Tests that reading from a flatbuffer over multiple threads is thread-safe in regard to double and float 879 // values, since they previously were non-thread safe 880 const float floatValue = 3.141592F; 881 const double doubleValue = 1.618033988; 882 883 var fbb = new FlatBufferBuilder(1); 884 var str = fbb.CreateString("ParallelTest"); 885 Monster.StartMonster(fbb); 886 Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, floatValue, doubleValue, 887 Color.Green, (short)5, (sbyte)6)); 888 889 Monster.AddName(fbb, str); 890 Monster.FinishMonsterBuffer(fbb, Monster.EndMonster(fbb)); 891 892 var mon = Monster.GetRootAsMonster(fbb.DataBuffer); 893 894 var pos = mon.Pos.Value; 895 Assert.AreEqual(pos.Test1, doubleValue); 896 Assert.AreEqual(pos.Z, floatValue); 897 898 const int thread_count = 10; 899 const int reps = 1000000; 900 901 // Need to use raw Threads since Tasks are not supported in .NET 3.5 902 Thread[] threads = new Thread[thread_count]; 903 for(int i = 0; i < thread_count; i++) { 904 threads[i] = new Thread(() => KeepComparing(mon, reps, floatValue, doubleValue)); 905 } 906 for(int i = 0; i < thread_count; i++) { 907 threads[i].Start(); 908 } 909 for(int i = 0; i < thread_count; i++) { 910 threads[i].Join(); 911 } 912 913 // Make sure the threads actually did the comparisons. 914 Assert.AreEqual(thread_count * reps, _comparisons); 915 916 // Make sure we never read the values incorrectly. 917 Assert.AreEqual(0, _failures); 918 } 919 920 [FlatBuffersTestMethod] TestScalarOptional_EmptyBuffer()921 public void TestScalarOptional_EmptyBuffer() { 922 var fbb = new FlatBufferBuilder(1); 923 ScalarStuff.StartScalarStuff(fbb); 924 var offset = ScalarStuff.EndScalarStuff(fbb); 925 ScalarStuff.FinishScalarStuffBuffer(fbb, offset); 926 927 ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer); 928 Assert.AreEqual((sbyte)0, scalarStuff.JustI8); 929 Assert.AreEqual(null, scalarStuff.MaybeI8); 930 Assert.AreEqual((sbyte)42, scalarStuff.DefaultI8); 931 Assert.AreEqual((byte)0, scalarStuff.JustU8); 932 Assert.AreEqual(null, scalarStuff.MaybeU8); 933 Assert.AreEqual((byte)42, scalarStuff.DefaultU8); 934 935 Assert.AreEqual((short)0, scalarStuff.JustI16); 936 Assert.AreEqual(null, scalarStuff.MaybeI16); 937 Assert.AreEqual((short)42, scalarStuff.DefaultI16); 938 Assert.AreEqual((ushort)0, scalarStuff.JustU16); 939 Assert.AreEqual(null, scalarStuff.MaybeU16); 940 Assert.AreEqual((ushort)42, scalarStuff.DefaultU16); 941 942 Assert.AreEqual((int)0, scalarStuff.JustI32); 943 Assert.AreEqual(null, scalarStuff.MaybeI32); 944 Assert.AreEqual((int)42, scalarStuff.DefaultI32); 945 Assert.AreEqual((uint)0, scalarStuff.JustU32); 946 Assert.AreEqual(null, scalarStuff.MaybeU32); 947 Assert.AreEqual((uint)42, scalarStuff.DefaultU32); 948 949 Assert.AreEqual((long)0, scalarStuff.JustI64); 950 Assert.AreEqual(null, scalarStuff.MaybeI64); 951 Assert.AreEqual((long)42, scalarStuff.DefaultI64); 952 Assert.AreEqual((ulong)0, scalarStuff.JustU64); 953 Assert.AreEqual(null, scalarStuff.MaybeU64); 954 Assert.AreEqual((ulong)42, scalarStuff.DefaultU64); 955 956 Assert.AreEqual((float)0.0F, scalarStuff.JustF32); 957 Assert.AreEqual(null, scalarStuff.MaybeF32); 958 Assert.AreEqual((float)42.0F, scalarStuff.DefaultF32); 959 960 Assert.AreEqual((double)0.0, scalarStuff.JustF64); 961 Assert.AreEqual(null, scalarStuff.MaybeF64); 962 Assert.AreEqual((double)42.0, scalarStuff.DefaultF64); 963 964 Assert.AreEqual(false, scalarStuff.JustBool); 965 Assert.AreEqual(null, scalarStuff.MaybeBool); 966 Assert.AreEqual(true, scalarStuff.DefaultBool); 967 968 Assert.AreEqual(OptionalByte.None, scalarStuff.JustEnum); 969 Assert.AreEqual(null, scalarStuff.MaybeEnum); 970 Assert.AreEqual(OptionalByte.One, scalarStuff.DefaultEnum); 971 } 972 973 [FlatBuffersTestMethod] TestScalarOptional_Construction()974 public void TestScalarOptional_Construction() { 975 var fbb = new FlatBufferBuilder(1); 976 ScalarStuff.StartScalarStuff(fbb); 977 ScalarStuff.AddJustI8(fbb, 5); 978 ScalarStuff.AddMaybeI8(fbb, 5); 979 ScalarStuff.AddDefaultI8(fbb, 5); 980 ScalarStuff.AddJustU8(fbb, 6); 981 ScalarStuff.AddMaybeU8(fbb, 6); 982 ScalarStuff.AddDefaultU8(fbb, 6); 983 984 ScalarStuff.AddJustI16(fbb, 7); 985 ScalarStuff.AddMaybeI16(fbb, 7); 986 ScalarStuff.AddDefaultI16(fbb, 7); 987 ScalarStuff.AddJustU16(fbb, 8); 988 ScalarStuff.AddMaybeU16(fbb, 8); 989 ScalarStuff.AddDefaultU16(fbb, 8); 990 991 ScalarStuff.AddJustI32(fbb, 9); 992 ScalarStuff.AddMaybeI32(fbb, 9); 993 ScalarStuff.AddDefaultI32(fbb, 9); 994 ScalarStuff.AddJustU32(fbb, 10); 995 ScalarStuff.AddMaybeU32(fbb, 10); 996 ScalarStuff.AddDefaultU32(fbb, 10); 997 998 ScalarStuff.AddJustI64(fbb, 11); 999 ScalarStuff.AddMaybeI64(fbb, 11); 1000 ScalarStuff.AddDefaultI64(fbb, 11); 1001 ScalarStuff.AddJustU64(fbb, 12); 1002 ScalarStuff.AddMaybeU64(fbb, 12); 1003 ScalarStuff.AddDefaultU64(fbb, 12); 1004 1005 ScalarStuff.AddJustF32(fbb, 13.0f); 1006 ScalarStuff.AddMaybeF32(fbb, 13.0f); 1007 ScalarStuff.AddDefaultF32(fbb, 13.0f); 1008 ScalarStuff.AddJustF64(fbb, 14.0); 1009 ScalarStuff.AddMaybeF64(fbb, 14.0); 1010 ScalarStuff.AddDefaultF64(fbb, 14.0); 1011 1012 ScalarStuff.AddJustBool(fbb, true); 1013 ScalarStuff.AddMaybeBool(fbb, true); 1014 ScalarStuff.AddDefaultBool(fbb, false); // note this is the opposite 1015 1016 ScalarStuff.AddJustEnum(fbb, OptionalByte.Two); 1017 ScalarStuff.AddMaybeEnum(fbb, OptionalByte.Two); 1018 ScalarStuff.AddDefaultEnum(fbb, OptionalByte.Two); 1019 1020 var offset = ScalarStuff.EndScalarStuff(fbb); 1021 ScalarStuff.FinishScalarStuffBuffer(fbb, offset); 1022 1023 ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer); 1024 Assert.AreEqual((sbyte)5, scalarStuff.JustI8); 1025 Assert.AreEqual((sbyte)5, scalarStuff.MaybeI8); 1026 Assert.AreEqual((sbyte)5, scalarStuff.DefaultI8); 1027 Assert.AreEqual((byte)6, scalarStuff.JustU8); 1028 Assert.AreEqual((byte)6, scalarStuff.MaybeU8); 1029 Assert.AreEqual((byte)6, scalarStuff.DefaultU8); 1030 1031 Assert.AreEqual((short)7, scalarStuff.JustI16); 1032 Assert.AreEqual((short)7, scalarStuff.MaybeI16); 1033 Assert.AreEqual((short)7, scalarStuff.DefaultI16); 1034 Assert.AreEqual((ushort)8, scalarStuff.JustU16); 1035 Assert.AreEqual((ushort)8, scalarStuff.MaybeU16); 1036 Assert.AreEqual((ushort)8, scalarStuff.DefaultU16); 1037 1038 Assert.AreEqual((int)9, scalarStuff.JustI32); 1039 Assert.AreEqual((int)9, scalarStuff.MaybeI32); 1040 Assert.AreEqual((int)9, scalarStuff.DefaultI32); 1041 Assert.AreEqual((uint)10, scalarStuff.JustU32); 1042 Assert.AreEqual((uint)10, scalarStuff.MaybeU32); 1043 Assert.AreEqual((uint)10, scalarStuff.DefaultU32); 1044 1045 Assert.AreEqual((long)11, scalarStuff.JustI64); 1046 Assert.AreEqual((long)11, scalarStuff.MaybeI64); 1047 Assert.AreEqual((long)11, scalarStuff.DefaultI64); 1048 Assert.AreEqual((ulong)12, scalarStuff.JustU64); 1049 Assert.AreEqual((ulong)12, scalarStuff.MaybeU64); 1050 Assert.AreEqual((ulong)12, scalarStuff.DefaultU64); 1051 1052 Assert.AreEqual((float)13.0F, scalarStuff.JustF32); 1053 Assert.AreEqual((float)13.0F, scalarStuff.MaybeF32); 1054 Assert.AreEqual((float)13.0F, scalarStuff.DefaultF32); 1055 1056 Assert.AreEqual((double)14.0, scalarStuff.JustF64); 1057 Assert.AreEqual((double)14.0, scalarStuff.MaybeF64); 1058 Assert.AreEqual((double)14.0, scalarStuff.DefaultF64); 1059 1060 Assert.AreEqual(true, scalarStuff.JustBool); 1061 Assert.AreEqual(true, scalarStuff.MaybeBool); 1062 Assert.AreEqual(false, scalarStuff.DefaultBool); 1063 1064 Assert.AreEqual(OptionalByte.Two, scalarStuff.JustEnum); 1065 Assert.AreEqual(OptionalByte.Two, scalarStuff.MaybeEnum); 1066 Assert.AreEqual(OptionalByte.Two, scalarStuff.DefaultEnum); 1067 } 1068 1069 [FlatBuffersTestMethod] TestScalarOptional_Construction_CreatorMethod()1070 public void TestScalarOptional_Construction_CreatorMethod() { 1071 var fbb = new FlatBufferBuilder(1); 1072 1073 var offset = ScalarStuff.CreateScalarStuff(fbb,5,5,5,6,6,6,7,7,7, 1074 8,8,8,9,9,9,10,10,10,11,11,11,12,12,12,13.0f,13.0f,13.0f,14.0, 1075 14.0,14.0,true,true,false,OptionalByte.Two,OptionalByte.Two, 1076 OptionalByte.Two); 1077 ScalarStuff.FinishScalarStuffBuffer(fbb, offset); 1078 1079 ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer); 1080 Assert.AreEqual((sbyte)5, scalarStuff.JustI8); 1081 Assert.AreEqual((sbyte)5, scalarStuff.MaybeI8); 1082 Assert.AreEqual((sbyte)5, scalarStuff.DefaultI8); 1083 Assert.AreEqual((byte)6, scalarStuff.JustU8); 1084 Assert.AreEqual((byte)6, scalarStuff.MaybeU8); 1085 Assert.AreEqual((byte)6, scalarStuff.DefaultU8); 1086 1087 Assert.AreEqual((short)7, scalarStuff.JustI16); 1088 Assert.AreEqual((short)7, scalarStuff.MaybeI16); 1089 Assert.AreEqual((short)7, scalarStuff.DefaultI16); 1090 Assert.AreEqual((ushort)8, scalarStuff.JustU16); 1091 Assert.AreEqual((ushort)8, scalarStuff.MaybeU16); 1092 Assert.AreEqual((ushort)8, scalarStuff.DefaultU16); 1093 1094 Assert.AreEqual((int)9, scalarStuff.JustI32); 1095 Assert.AreEqual((int)9, scalarStuff.MaybeI32); 1096 Assert.AreEqual((int)9, scalarStuff.DefaultI32); 1097 Assert.AreEqual((uint)10, scalarStuff.JustU32); 1098 Assert.AreEqual((uint)10, scalarStuff.MaybeU32); 1099 Assert.AreEqual((uint)10, scalarStuff.DefaultU32); 1100 1101 Assert.AreEqual((long)11, scalarStuff.JustI64); 1102 Assert.AreEqual((long)11, scalarStuff.MaybeI64); 1103 Assert.AreEqual((long)11, scalarStuff.DefaultI64); 1104 Assert.AreEqual((ulong)12, scalarStuff.JustU64); 1105 Assert.AreEqual((ulong)12, scalarStuff.MaybeU64); 1106 Assert.AreEqual((ulong)12, scalarStuff.DefaultU64); 1107 1108 Assert.AreEqual((float)13.0F, scalarStuff.JustF32); 1109 Assert.AreEqual((float)13.0F, scalarStuff.MaybeF32); 1110 Assert.AreEqual((float)13.0F, scalarStuff.DefaultF32); 1111 1112 Assert.AreEqual((double)14.0, scalarStuff.JustF64); 1113 Assert.AreEqual((double)14.0, scalarStuff.MaybeF64); 1114 Assert.AreEqual((double)14.0, scalarStuff.DefaultF64); 1115 1116 Assert.AreEqual(true, scalarStuff.JustBool); 1117 Assert.AreEqual(true, scalarStuff.MaybeBool); 1118 Assert.AreEqual(false, scalarStuff.DefaultBool); 1119 1120 Assert.AreEqual(OptionalByte.Two, scalarStuff.JustEnum); 1121 Assert.AreEqual(OptionalByte.Two, scalarStuff.MaybeEnum); 1122 Assert.AreEqual(OptionalByte.Two, scalarStuff.DefaultEnum); 1123 } 1124 1125 1126 [FlatBuffersTestMethod] TestKeywordEscaping()1127 public void TestKeywordEscaping() { 1128 Assert.AreEqual((int)KeywordTest.@public.NONE, 0); 1129 1130 Assert.AreEqual((int)KeywordTest.ABC.@void, 0); 1131 Assert.AreEqual((int)KeywordTest.ABC.where, 1); 1132 Assert.AreEqual((int)KeywordTest.ABC.@stackalloc, 2); 1133 1134 var fbb = new FlatBufferBuilder(1); 1135 var offset = KeywordsInTable.CreateKeywordsInTable( 1136 fbb, KeywordTest.ABC.@stackalloc, KeywordTest.@public.NONE); 1137 fbb.Finish(offset.Value); 1138 1139 KeywordsInTable keywordsInTable = 1140 KeywordsInTable.GetRootAsKeywordsInTable(fbb.DataBuffer); 1141 1142 Assert.AreEqual(keywordsInTable.Is, KeywordTest.ABC.@stackalloc); 1143 Assert.AreEqual(keywordsInTable.Private, KeywordTest.@public.NONE); 1144 } 1145 1146 1147 [FlatBuffersTestMethod] AddOptionalEnum_WhenPassNull_ShouldWorkProperly()1148 public void AddOptionalEnum_WhenPassNull_ShouldWorkProperly() { 1149 var fbb = new FlatBufferBuilder(1); 1150 ScalarStuff.StartScalarStuff(fbb); 1151 ScalarStuff.AddMaybeEnum(fbb, null); 1152 var offset = ScalarStuff.EndScalarStuff(fbb); 1153 ScalarStuff.FinishScalarStuffBuffer(fbb, offset); 1154 1155 ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer); 1156 Assert.AreEqual(null, scalarStuff.MaybeEnum); 1157 } 1158 1159 1160 [FlatBuffersTestMethod] SortKey_WithDefaultedValue_IsFindable()1161 public void SortKey_WithDefaultedValue_IsFindable() { 1162 // This checks if using the `key` attribute that includes the 1163 // default value (e.g., 0) is still searchable. This is a regression 1164 // test for https://github.com/google/flatbuffers/issues/7380. 1165 var fbb = new FlatBufferBuilder(1); 1166 1167 // Create a vector of Stat objects, with Count being the key. 1168 var stat_offsets = new Offset<Stat>[4]; 1169 for(ushort i = 0; i < stat_offsets.Length; i++) { 1170 Stat.StartStat(fbb); 1171 Stat.AddCount(fbb, i); 1172 stat_offsets[stat_offsets.Length - 1 - i] = Stat.EndStat(fbb); 1173 } 1174 1175 // Ensure the sort works. 1176 var sort = Stat.CreateSortedVectorOfStat(fbb, stat_offsets); 1177 1178 // Create the monster with the sorted vector of Stat objects. 1179 var str = fbb.CreateString("MyMonster"); 1180 Monster.StartMonster(fbb); 1181 Monster.AddName(fbb, str); 1182 Monster.AddScalarKeySortedTables(fbb, sort); 1183 fbb.Finish(Monster.EndMonster(fbb).Value); 1184 1185 // Get the monster. 1186 var monster = Monster.GetRootAsMonster(fbb.DataBuffer); 1187 1188 // Ensure each key is findable. 1189 for(ushort i =0 ; i < stat_offsets.Length; i++) { 1190 Assert.IsTrue(monster.ScalarKeySortedTablesByKey(i) != null); 1191 Assert.AreEqual(monster.ScalarKeySortedTablesByKey(i).Value.Count, i); 1192 } 1193 } 1194 } 1195 } 1196