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