1 /* 2 * Copyright 2015 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; 18 19 namespace FlatBuffers.Test 20 { 21 [FlatBuffersTestClass] 22 public class FlatBuffersFuzzTests 23 { 24 private readonly Lcg _lcg = new Lcg(); 25 26 [FlatBuffersTestMethod] TestObjects()27 public void TestObjects() 28 { 29 CheckObjects(11, 100); 30 } 31 32 [FlatBuffersTestMethod] TestNumbers()33 public void TestNumbers() 34 { 35 var builder = new FlatBufferBuilder(1); 36 Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); 37 builder.AddBool(true); 38 Assert.ArrayEqual(new byte[] { 1 }, builder.DataBuffer.ToFullArray()); 39 builder.AddSbyte(-127); 40 Assert.ArrayEqual(new byte[] { 129, 1 }, builder.DataBuffer.ToFullArray()); 41 builder.AddByte(255); 42 Assert.ArrayEqual(new byte[] { 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // First pad 43 builder.AddShort(-32222); 44 Assert.ArrayEqual(new byte[] { 0, 0, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // Second pad 45 builder.AddUshort(0xFEEE); 46 Assert.ArrayEqual(new byte[] { 0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // no pad 47 builder.AddInt(-53687092); 48 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 204, 204, 204, 252, 0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // third pad 49 builder.AddUint(0x98765432); 50 Assert.ArrayEqual(new byte[] { 0x32, 0x54, 0x76, 0x98, 204, 204, 204, 252, 0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1 }, builder.DataBuffer.ToFullArray()); // no pad 51 } 52 53 [FlatBuffersTestMethod] TestNumbers64()54 public void TestNumbers64() 55 { 56 var builder = new FlatBufferBuilder(1); 57 builder.AddUlong(0x1122334455667788); 58 Assert.ArrayEqual(new byte[] { 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 }, builder.DataBuffer.ToFullArray()); 59 60 builder = new FlatBufferBuilder(1); 61 builder.AddLong(0x1122334455667788); 62 Assert.ArrayEqual(new byte[] { 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 }, builder.DataBuffer.ToFullArray()); 63 } 64 65 [FlatBuffersTestMethod] TestVector_1xUInt8()66 public void TestVector_1xUInt8() 67 { 68 var builder = new FlatBufferBuilder(1); 69 builder.StartVector(sizeof(byte), 1, 1); 70 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.ToFullArray()); 71 builder.AddByte(1); 72 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.ToFullArray()); 73 builder.EndVector(); 74 Assert.ArrayEqual(new byte[] { 1, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.ToFullArray()); 75 } 76 77 [FlatBuffersTestMethod] TestVector_2xUint8()78 public void TestVector_2xUint8() 79 { 80 var builder = new FlatBufferBuilder(1); 81 builder.StartVector(sizeof(byte), 2, 1); 82 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.ToFullArray()); 83 builder.AddByte(1); 84 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, builder.DataBuffer.ToFullArray()); 85 builder.AddByte(2); 86 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 2, 1, 0, 0 }, builder.DataBuffer.ToFullArray()); 87 builder.EndVector(); 88 Assert.ArrayEqual(new byte[] { 2, 0, 0, 0, 2, 1, 0, 0 }, builder.DataBuffer.ToFullArray()); 89 } 90 91 [FlatBuffersTestMethod] TestVector_1xUInt16()92 public void TestVector_1xUInt16() 93 { 94 var builder = new FlatBufferBuilder(1); 95 builder.StartVector(sizeof(ushort), 1, 1); 96 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.ToFullArray()); 97 builder.AddUshort(1); 98 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.ToFullArray()); 99 builder.EndVector(); 100 Assert.ArrayEqual(new byte[] { 1, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.ToFullArray()); 101 } 102 103 [FlatBuffersTestMethod] TestVector_2xUInt16()104 public void TestVector_2xUInt16() 105 { 106 var builder = new FlatBufferBuilder(1); 107 builder.StartVector(sizeof(ushort), 2, 1); 108 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.ToFullArray()); 109 builder.AddUshort(0xABCD); 110 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0xCD, 0xAB }, builder.DataBuffer.ToFullArray()); 111 builder.AddUshort(0xDCBA); 112 Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0xBA, 0xDC, 0xCD, 0xAB }, builder.DataBuffer.ToFullArray()); 113 builder.EndVector(); 114 Assert.ArrayEqual(new byte[] { 2, 0, 0, 0, 0xBA, 0xDC, 0xCD, 0xAB }, builder.DataBuffer.ToFullArray()); 115 } 116 117 [FlatBuffersTestMethod] TestCreateAsciiString()118 public void TestCreateAsciiString() 119 { 120 var builder = new FlatBufferBuilder(1); 121 builder.CreateString("foo"); 122 Assert.ArrayEqual(new byte[] { 3, 0, 0, 0, (byte)'f', (byte)'o', (byte)'o', 0 }, builder.DataBuffer.ToFullArray()); 123 124 builder.CreateString("moop"); 125 Assert.ArrayEqual(new byte[] 126 { 127 0, 0, 0, 0, 128 0, 0, 0, 0, 129 0, 0, 0, 0, // Padding to 32 bytes 130 4, 0, 0, 0, 131 (byte)'m', (byte)'o', (byte)'o', (byte)'p', 132 0, 0, 0, 0, // zero terminator with 3 byte pad 133 3, 0, 0, 0, 134 (byte)'f', (byte)'o', (byte)'o', 0 135 }, builder.DataBuffer.ToFullArray()); 136 } 137 138 [FlatBuffersTestMethod] TestCreateArbitarytring()139 public void TestCreateArbitarytring() 140 { 141 var builder = new FlatBufferBuilder(1); 142 builder.CreateString("\x01\x02\x03"); 143 Assert.ArrayEqual(new byte[] 144 { 145 3, 0, 0, 0, 146 0x01, 0x02, 0x03, 0 147 }, builder.DataBuffer.ToFullArray()); // No padding 148 builder.CreateString("\x04\x05\x06\x07"); 149 Assert.ArrayEqual(new byte[] 150 { 151 0, 0, 0, 0, 152 0, 0, 0, 0, 153 0, 0, 0, 0, // Padding to 32 bytes 154 4, 0, 0, 0, 155 0x04, 0x05, 0x06, 0x07, 156 0, 0, 0, 0, // zero terminator with 3 byte pad 157 3, 0, 0, 0, 158 0x01, 0x02, 0x03, 0 159 }, builder.DataBuffer.ToFullArray()); // No padding 160 } 161 162 [FlatBuffersTestMethod] TestEmptyVTable()163 public void TestEmptyVTable() 164 { 165 var builder = new FlatBufferBuilder(1); 166 builder.StartObject(0); 167 Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); 168 builder.EndObject(); 169 Assert.ArrayEqual(new byte[] 170 { 171 4, 0, 4, 0, 172 4, 0, 0, 0 173 }, 174 builder.DataBuffer.ToFullArray()); 175 } 176 177 [FlatBuffersTestMethod] TestVTableWithOneBool()178 public void TestVTableWithOneBool() 179 { 180 var builder = new FlatBufferBuilder(1); 181 builder.StartObject(1); 182 Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); 183 builder.AddBool(0, true, false); 184 builder.EndObject(); 185 Assert.ArrayEqual(new byte[] 186 { 187 0, 0, // padding to 16 bytes 188 6, 0, // vtable bytes 189 8, 0, // object length inc vtable offset 190 7, 0, // start of bool value 191 6, 0, 0, 0, // int32 offset for start of vtable 192 0, 0, 0, // padding 193 1, // value 0 194 }, 195 builder.DataBuffer.ToFullArray()); 196 } 197 198 [FlatBuffersTestMethod] TestVTableWithOneBool_DefaultValue()199 public void TestVTableWithOneBool_DefaultValue() 200 { 201 var builder = new FlatBufferBuilder(1); 202 builder.StartObject(1); 203 Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); 204 builder.AddBool(0, false, false); 205 builder.EndObject(); 206 Assert.ArrayEqual(new byte[] 207 { 208 // No padding. 209 4, 0, // vtable bytes 210 4, 0, // end of object from here 211 // entry 0 is not stored (trimmed end of vtable) 212 4, 0, 0, 0, // int32 offset for start of vtable 213 }, 214 builder.DataBuffer.ToFullArray()); 215 } 216 217 [FlatBuffersTestMethod] TestVTableWithOneInt16()218 public void TestVTableWithOneInt16() 219 { 220 var builder = new FlatBufferBuilder(1); 221 builder.StartObject(1); 222 Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); 223 builder.AddShort(0, 0x789A, 0); 224 builder.EndObject(); 225 Assert.ArrayEqual(new byte[] 226 { 227 0, 0, // padding to 16 bytes 228 6, 0, // vtable bytes 229 8, 0, // object length inc vtable offset 230 6, 0, // start of int16 value 231 6, 0, 0, 0, // int32 offset for start of vtable 232 0, 0, // padding 233 0x9A, 0x78, //value 0 234 }, 235 builder.DataBuffer.ToFullArray()); 236 } 237 238 [FlatBuffersTestMethod] TestVTableWithTwoInt16()239 public void TestVTableWithTwoInt16() 240 { 241 var builder = new FlatBufferBuilder(1); 242 builder.StartObject(2); 243 Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); 244 builder.AddShort(0, 0x3456, 0); 245 builder.AddShort(1, 0x789A, 0); 246 builder.EndObject(); 247 Assert.ArrayEqual(new byte[] 248 { 249 8, 0, // vtable bytes 250 8, 0, // object length inc vtable offset 251 6, 0, // start of int16 value 0 252 4, 0, // start of int16 value 1 253 8, 0, 0, 0, // int32 offset for start of vtable 254 0x9A, 0x78, // value 1 255 0x56, 0x34, // value 0 256 }, 257 builder.DataBuffer.ToFullArray()); 258 } 259 260 [FlatBuffersTestMethod] TestVTableWithInt16AndBool()261 public void TestVTableWithInt16AndBool() 262 { 263 var builder = new FlatBufferBuilder(1); 264 builder.StartObject(2); 265 Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); 266 builder.AddShort(0, 0x3456, 0); 267 builder.AddBool(1, true, false); 268 builder.EndObject(); 269 Assert.ArrayEqual(new byte[] 270 { 271 8, 0, // vtable bytes 272 8, 0, // object length inc vtable offset 273 6, 0, // start of int16 value 0 274 5, 0, // start of bool value 1 275 8, 0, 0, 0, // int32 offset for start of vtable 276 0, 1, // padding + value 1 277 0x56, 0x34, // value 0 278 }, 279 builder.DataBuffer.ToFullArray()); 280 } 281 282 [FlatBuffersTestMethod] TestVTableWithEmptyVector()283 public void TestVTableWithEmptyVector() 284 { 285 var builder = new FlatBufferBuilder(1); 286 builder.StartVector(sizeof(byte), 0, 1); 287 var vecEnd = builder.EndVector(); 288 289 builder.StartObject(1); 290 291 builder.AddOffset(0, vecEnd.Value, 0); 292 builder.EndObject(); 293 Assert.ArrayEqual(new byte[] 294 { 295 0, 0, 0, 0, 296 0, 0, 0, 0, 297 0, 0, 0, 0, 298 0, 0, // Padding to 32 bytes 299 6, 0, // vtable bytes 300 8, 0, // object length inc vtable offset 301 4, 0, // start of vector offset value 0 302 6, 0, 0, 0, // int32 offset for start of vtable 303 4, 0, 0, 0, 304 0, 0, 0, 0, 305 }, 306 builder.DataBuffer.ToFullArray()); 307 } 308 309 [FlatBuffersTestMethod] TestVTableWithEmptyVectorAndScalars()310 public void TestVTableWithEmptyVectorAndScalars() 311 { 312 var builder = new FlatBufferBuilder(1); 313 builder.StartVector(sizeof(byte), 0, 1); 314 var vecEnd = builder.EndVector(); 315 316 builder.StartObject(2); 317 builder.AddShort(0, 55, 0); 318 builder.AddOffset(1, vecEnd.Value, 0); 319 builder.EndObject(); 320 Assert.ArrayEqual(new byte[] 321 { 322 0, 0, 0, 0, 323 0, 0, 0, 0, // Padding to 32 bytes 324 8, 0, // vtable bytes 325 12, 0, // object length inc vtable offset 326 10, 0, // offset to int16 value 0 327 4, 0, // start of vector offset value 1 328 8, 0, 0, 0, // int32 offset for start of vtable 329 8, 0, 0, 0, // value 1 330 0, 0, 55, 0, // value 0 331 0, 0, 0, 0, // length of vector (not in sctruc) 332 }, 333 builder.DataBuffer.ToFullArray()); 334 } 335 336 337 [FlatBuffersTestMethod] TestVTableWith_1xInt16_and_Vector_or_2xInt16()338 public void TestVTableWith_1xInt16_and_Vector_or_2xInt16() 339 { 340 var builder = new FlatBufferBuilder(1); 341 builder.StartVector(sizeof(short), 2, 1); 342 builder.AddShort(0x1234); 343 builder.AddShort(0x5678); 344 var vecEnd = builder.EndVector(); 345 346 builder.StartObject(2); 347 builder.AddOffset(1, vecEnd.Value, 0); 348 builder.AddShort(0, 55, 0); 349 builder.EndObject(); 350 Assert.ArrayEqual(new byte[] 351 { 352 0, 0, 0, 0, // Padding to 32 bytes 353 8, 0, // vtable bytes 354 12, 0, // object length 355 6, 0, // start of value 0 from end of vtable 356 8, 0, // start of value 1 from end of buffer 357 8, 0, 0, 0, // int32 offset for start of vtable 358 0, 0, 55, 0, // padding + value 0 359 4, 0, 0, 0, // position of vector from here 360 2, 0, 0, 0, // length of vector 361 0x78, 0x56, // vector value 0 362 0x34, 0x12, // vector value 1 363 }, 364 builder.DataBuffer.ToFullArray()); 365 } 366 367 [FlatBuffersTestMethod] TestVTableWithAStruct_of_int8_int16_int32()368 public void TestVTableWithAStruct_of_int8_int16_int32() 369 { 370 var builder = new FlatBufferBuilder(1); 371 builder.StartObject(1); 372 builder.Prep(4+4+4, 0); 373 builder.AddSbyte(55); 374 builder.Pad(3); 375 builder.AddShort(0x1234); 376 builder.Pad(2); 377 builder.AddInt(0x12345678); 378 var structStart = builder.Offset; 379 builder.AddStruct(0, structStart, 0); 380 builder.EndObject(); 381 Assert.ArrayEqual(new byte[] 382 { 383 0, 0, 0, 0, 384 0, 0, 0, 0, 385 0, 0, // Padding to 32 bytes 386 6, 0, // vtable bytes 387 16, 0, // object length 388 4, 0, // start of struct from here 389 6, 0, 0, 0, // int32 offset for start of vtable 390 0x78, 0x56, 0x34, 0x12, // struct value 2 391 0x00, 0x00, 0x34, 0x12, // struct value 1 392 0x00, 0x00, 0x00, 55, // struct value 0 393 }, 394 builder.DataBuffer.ToFullArray()); 395 } 396 397 [FlatBuffersTestMethod] TestVTableWithAVectorOf_2xStructOf_2xInt8()398 public void TestVTableWithAVectorOf_2xStructOf_2xInt8() 399 { 400 var builder = new FlatBufferBuilder(1); 401 builder.StartVector(sizeof(byte)*2, 2, 1); 402 builder.AddByte(33); 403 builder.AddByte(44); 404 builder.AddByte(55); 405 builder.AddByte(66); 406 var vecEnd = builder.EndVector(); 407 408 builder.StartObject(1); 409 builder.AddOffset(0, vecEnd.Value, 0); 410 builder.EndObject(); 411 412 Assert.ArrayEqual(new byte[] 413 { 414 0, 0, 0, 0, 415 0, 0, 0, 0, 416 0, 0, // Padding to 32 bytes 417 6, 0, // vtable bytes 418 8, 0, // object length 419 4, 0, // offset of vector offset 420 6, 0, 0, 0, // int32 offset for start of vtable 421 4, 0, 0, 0, // Vector start offset 422 2, 0, 0, 0, // Vector len 423 66, // vector 1, 1 424 55, // vector 1, 0 425 44, // vector 0, 1 426 33, // vector 0, 0 427 }, 428 builder.DataBuffer.ToFullArray()); 429 } 430 431 [FlatBuffersTestMethod] TestVTableWithSomeElements()432 public void TestVTableWithSomeElements() 433 { 434 var builder = new FlatBufferBuilder(1); 435 builder.StartObject(2); 436 builder.AddByte(0, 33, 0); 437 builder.AddShort(1, 66, 0); 438 var off = builder.EndObject(); 439 builder.Finish(off); 440 441 byte[] padded = new byte[] 442 { 443 0, 0, 0, 0, 444 0, 0, 0, 0, 445 0, 0, 0, 0, //Padding to 32 bytes 446 12, 0, 0, 0, // root of table, pointing to vtable offset 447 8, 0, // vtable bytes 448 8, 0, // object length 449 7, 0, // start of value 0 450 4, 0, // start of value 1 451 8, 0, 0, 0, // int32 offset for start of vtable 452 66, 0, // value 1 453 0, 33, // value 0 454 455 }; 456 Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray()); 457 458 // no padding in sized array 459 byte[] unpadded = new byte[padded.Length - 12]; 460 Buffer.BlockCopy(padded, 12, unpadded, 0, unpadded.Length); 461 Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray()); 462 } 463 464 [FlatBuffersTestMethod] TestTwoFinishTable()465 public void TestTwoFinishTable() 466 { 467 var builder = new FlatBufferBuilder(1); 468 builder.StartObject(2); 469 builder.AddByte(0, 33, 0); 470 builder.AddByte(1, 44, 0); 471 var off0 = builder.EndObject(); 472 builder.Finish(off0); 473 474 builder.StartObject(3); 475 builder.AddByte(0, 55, 0); 476 builder.AddByte(1, 66, 0); 477 builder.AddByte(2, 77, 0); 478 var off1 = builder.EndObject(); 479 builder.Finish(off1); 480 481 Assert.ArrayEqual(new byte[] 482 { 483 0, 0, 0, 0, 484 0, 0, 0, 0, 485 0, 0, 0, 0, 486 0, 0, 0, 0, 487 0, 0, 0, 0, // padding to 64 bytes 488 16, 0, 0, 0, // root of table, pointing to vtable offset (obj1) 489 0, 0, // padding 490 491 10, 0, // vtable bytes 492 8, 0, // object length 493 7, 0, // start of value 0 494 6, 0, // start of value 1 495 5, 0, // start of value 2 496 10, 0, 0, 0, // int32 offset for start of vtable 497 0, // pad 498 77, // values 2, 1, 0 499 66, 500 55, 501 502 12, 0, 0, 0, // root of table, pointing to vtable offset (obj0) 503 8, 0, // vtable bytes 504 8, 0, // object length 505 7, 0, // start of value 0 506 6, 0, // start of value 1 507 8, 0, 0, 0, // int32 offset for start of vtable 508 0, 0, // pad 509 44, // value 1, 0 510 33, 511 }, 512 builder.DataBuffer.ToFullArray()); 513 } 514 515 [FlatBuffersTestMethod] TestBunchOfBools()516 public void TestBunchOfBools() 517 { 518 var builder = new FlatBufferBuilder(1); 519 builder.StartObject(8); 520 for (var i = 0; i < 8; i++) 521 { 522 builder.AddBool(i, true, false); 523 } 524 var off = builder.EndObject(); 525 builder.Finish(off); 526 527 byte[] padded = new byte[] 528 { 529 0, 0, 0, 0, 530 0, 0, 0, 0, 531 0, 0, 0, 0, 532 0, 0, 0, 0, 533 0, 0, 0, 0, 534 0, 0, 0, 0, 535 0, 0, 0, 0, // padding to 64 bytes 536 537 24, 0, 0, 0, // root of table, pointing to vtable offset (obj0) 538 20, 0, // vtable bytes 539 12, 0, // object length 540 11, 0, // start of value 0 541 10, 0, // start of value 1 542 9, 0, // start of value 2 543 8, 0, // start of value 3 544 7, 0, // start of value 4 545 6, 0, // start of value 5 546 5, 0, // start of value 6 547 4, 0, // start of value 7 548 549 20, 0, 0, 0, // int32 offset for start of vtable 550 551 1, 1, 1, 1, // values 552 1, 1, 1, 1, 553 554 }; 555 Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray()); 556 557 // no padding in sized array 558 byte[] unpadded = new byte[padded.Length - 28]; 559 Buffer.BlockCopy(padded, 28, unpadded, 0, unpadded.Length); 560 Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray()); 561 } 562 563 [FlatBuffersTestMethod] TestBunchOfBoolsSizePrefixed()564 public void TestBunchOfBoolsSizePrefixed() 565 { 566 var builder = new FlatBufferBuilder(1); 567 builder.StartObject(8); 568 for (var i = 0; i < 8; i++) 569 { 570 builder.AddBool(i, true, false); 571 } 572 var off = builder.EndObject(); 573 builder.FinishSizePrefixed(off); 574 575 byte[] padded = new byte[] 576 { 577 0, 0, 0, 0, 578 0, 0, 0, 0, 579 0, 0, 0, 0, 580 0, 0, 0, 0, 581 0, 0, 0, 0, 582 0, 0, 0, 0, // padding to 64 bytes 583 584 36, 0, 0, 0, // size prefix 585 24, 0, 0, 0, // root of table, pointing to vtable offset (obj0) 586 20, 0, // vtable bytes 587 12, 0, // object length 588 11, 0, // start of value 0 589 10, 0, // start of value 1 590 9, 0, // start of value 2 591 8, 0, // start of value 3 592 7, 0, // start of value 4 593 6, 0, // start of value 5 594 5, 0, // start of value 6 595 4, 0, // start of value 7 596 597 20, 0, 0, 0, // int32 offset for start of vtable 598 599 1, 1, 1, 1, // values 600 1, 1, 1, 1, 601 602 }; 603 Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray()); 604 605 // no padding in sized array 606 byte[] unpadded = new byte[padded.Length - 24]; 607 Buffer.BlockCopy(padded, 24, unpadded, 0, unpadded.Length); 608 Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray()); 609 } 610 611 [FlatBuffersTestMethod] TestWithFloat()612 public void TestWithFloat() 613 { 614 var builder = new FlatBufferBuilder(1); 615 builder.StartObject(1); 616 builder.AddFloat(0, 1, 0); 617 builder.EndObject(); 618 619 620 Assert.ArrayEqual(new byte[] 621 { 622 0, 0, 623 6, 0, // vtable bytes 624 8, 0, // object length 625 4, 0, // start of value 0 626 6, 0, 0, 0, // int32 offset for start of vtable 627 0, 0, 128, 63, // value 628 629 }, 630 builder.DataBuffer.ToFullArray()); 631 } 632 CheckObjects(int fieldCount, int objectCount)633 private void CheckObjects(int fieldCount, int objectCount) 634 { 635 _lcg.Reset(); 636 637 const int testValuesMax = 11; 638 639 var builder = new FlatBufferBuilder(1); 640 641 var objects = new int[objectCount]; 642 643 for (var i = 0; i < objectCount; ++i) 644 { 645 builder.StartObject(fieldCount); 646 647 for (var j = 0; j < fieldCount; ++j) 648 { 649 var fieldType = _lcg.Next()%testValuesMax; 650 651 switch (fieldType) 652 { 653 case 0: 654 { 655 builder.AddBool(j, FuzzTestData.BoolValue, false); 656 break; 657 } 658 case 1: 659 { 660 builder.AddSbyte(j, FuzzTestData.Int8Value, 0); 661 break; 662 } 663 case 2: 664 { 665 builder.AddByte(j, FuzzTestData.UInt8Value, 0); 666 break; 667 } 668 case 3: 669 { 670 builder.AddShort(j, FuzzTestData.Int16Value, 0); 671 break; 672 } 673 case 4: 674 { 675 builder.AddUshort(j, FuzzTestData.UInt16Value, 0); 676 break; 677 } 678 case 5: 679 { 680 builder.AddInt(j, FuzzTestData.Int32Value, 0); 681 break; 682 } 683 case 6: 684 { 685 builder.AddUint(j, FuzzTestData.UInt32Value, 0); 686 break; 687 } 688 case 7: 689 { 690 builder.AddLong(j, FuzzTestData.Int64Value, 0); 691 break; 692 } 693 case 8: 694 { 695 builder.AddUlong(j, FuzzTestData.UInt64Value, 0); 696 break; 697 } 698 case 9: 699 { 700 builder.AddFloat(j, FuzzTestData.Float32Value, 0); 701 break; 702 } 703 case 10: 704 { 705 builder.AddDouble(j, FuzzTestData.Float64Value, 0); 706 break; 707 } 708 default: 709 throw new Exception("Unreachable"); 710 } 711 712 } 713 714 var offset = builder.EndObject(); 715 716 // Store the object offset 717 objects[i] = offset; 718 } 719 720 _lcg.Reset(); 721 722 // Test all objects are readable and return expected values... 723 for (var i = 0; i < objectCount; ++i) 724 { 725 var table = new TestTable(builder.DataBuffer, builder.DataBuffer.Length - objects[i]); 726 727 for (var j = 0; j < fieldCount; ++j) 728 { 729 var fieldType = _lcg.Next() % testValuesMax; 730 var fc = 2 + j; // 2 == VtableMetadataFields 731 var f = fc * 2; 732 733 switch (fieldType) 734 { 735 case 0: 736 { 737 Assert.AreEqual(FuzzTestData.BoolValue, table.GetSlot(f, false)); 738 break; 739 } 740 case 1: 741 { 742 Assert.AreEqual(FuzzTestData.Int8Value, table.GetSlot(f, (sbyte)0)); 743 break; 744 } 745 case 2: 746 { 747 Assert.AreEqual(FuzzTestData.UInt8Value, table.GetSlot(f, (byte)0)); 748 break; 749 } 750 case 3: 751 { 752 Assert.AreEqual(FuzzTestData.Int16Value, table.GetSlot(f, (short)0)); 753 break; 754 } 755 case 4: 756 { 757 Assert.AreEqual(FuzzTestData.UInt16Value, table.GetSlot(f, (ushort)0)); 758 break; 759 } 760 case 5: 761 { 762 Assert.AreEqual(FuzzTestData.Int32Value, table.GetSlot(f, (int)0)); 763 break; 764 } 765 case 6: 766 { 767 Assert.AreEqual(FuzzTestData.UInt32Value, table.GetSlot(f, (uint)0)); 768 break; 769 } 770 case 7: 771 { 772 Assert.AreEqual(FuzzTestData.Int64Value, table.GetSlot(f, (long)0)); 773 break; 774 } 775 case 8: 776 { 777 Assert.AreEqual(FuzzTestData.UInt64Value, table.GetSlot(f, (ulong)0)); 778 break; 779 } 780 case 9: 781 { 782 Assert.AreEqual(FuzzTestData.Float32Value, table.GetSlot(f, (float)0)); 783 break; 784 } 785 case 10: 786 { 787 Assert.AreEqual(FuzzTestData.Float64Value, table.GetSlot(f, (double)0)); 788 break; 789 } 790 default: 791 throw new Exception("Unreachable"); 792 } 793 794 } 795 796 } 797 798 } 799 } 800 } 801