1/*
2 * Copyright 2016 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
17using System;
18
19namespace Google.FlatBuffers.Test
20{
21 [FlatBuffersTestClass]
22 public class FlatBufferBuilderTests
23 {
24 private FlatBufferBuilder CreateBuffer(bool forceDefaults = true)
25 {
26 var fbb = new FlatBufferBuilder(16) {ForceDefaults = forceDefaults};
27 fbb.StartTable(1);
28 return fbb;
29 }
30
31 [FlatBuffersTestMethod]
32 public void FlatBufferBuilder_WithForceDefaults_WhenAddBool_AndDefaultValue_OffsetIncreasesBySize()
33 {
34 var fbb = CreateBuffer();
35 var storedOffset = fbb.Offset;
36 fbb.AddBool(0, false, false);
37 var endOffset = fbb.Offset;
38 Assert.AreEqual(sizeof(bool), endOffset-storedOffset);
39 }
40
41 [FlatBuffersTestMethod]
42 public void FlatBufferBuilder_WithForceDefaults_WhenAddSByte_AndDefaultValue_OffsetIncreasesBySize()
43 {
44 var fbb = CreateBuffer();
45 var storedOffset = fbb.Offset;
46 fbb.AddSbyte(0, 0, 0);
47 var endOffset = fbb.Offset;
48 Assert.AreEqual(sizeof(sbyte), endOffset - storedOffset);
49 }
50
51 [FlatBuffersTestMethod]
52 public void FlatBufferBuilder_WithForceDefaults_WhenAddByte_AndDefaultValue_OffsetIncreasesBySize()
53 {
54 var fbb = CreateBuffer();
55 var storedOffset = fbb.Offset;
56 fbb.AddByte(0, 0, 0);
57 var endOffset = fbb.Offset;
58 Assert.AreEqual(sizeof(byte), endOffset - storedOffset);
59 }
60
61 [FlatBuffersTestMethod]
62 public void FlatBufferBuilder_WithForceDefaults_WhenAddShort_AndDefaultValue_OffsetIncreasesBySize()
63 {
64 var fbb = CreateBuffer();
65 var storedOffset = fbb.Offset;
66 fbb.AddShort(0, 0, 0);
67 var endOffset = fbb.Offset;
68 Assert.AreEqual(sizeof(short), endOffset - storedOffset);
69 }
70
71 [FlatBuffersTestMethod]
72 public void FlatBufferBuilder_WithForceDefaults_WhenAddUShort_AndDefaultValue_OffsetIncreasesBySize()
73 {
74 var fbb = CreateBuffer();
75 var storedOffset = fbb.Offset;
76 fbb.AddUshort(0, 0, 0);
77 var endOffset = fbb.Offset;
78 Assert.AreEqual(sizeof(ushort), endOffset - storedOffset);
79 }
80
81 [FlatBuffersTestMethod]
82 public void FlatBufferBuilder_WithForceDefaults_WhenAddInt_AndDefaultValue_OffsetIncreasesBySize()
83 {
84 var fbb = CreateBuffer();
85 var storedOffset = fbb.Offset;
86 fbb.AddInt(0, 0, 0);
87 var endOffset = fbb.Offset;
88 Assert.AreEqual(sizeof(int), endOffset - storedOffset);
89 }
90
91 [FlatBuffersTestMethod]
92 public void FlatBufferBuilder_WithForceDefaults_WhenAddUInt_AndDefaultValue_OffsetIncreasesBySize()
93 {
94 var fbb = CreateBuffer();
95 var storedOffset = fbb.Offset;
96 fbb.AddUint(0, 0, 0);
97 var endOffset = fbb.Offset;
98 Assert.AreEqual(sizeof(uint), endOffset - storedOffset);
99 }
100
101 [FlatBuffersTestMethod]
102 public void FlatBufferBuilder_WithForceDefaults_WhenAddLong_AndDefaultValue_OffsetIncreasesBySize()
103 {
104 var fbb = CreateBuffer();
105 var storedOffset = fbb.Offset;
106 fbb.AddLong(0, 0, 0);
107 var endOffset = fbb.Offset;
108 Assert.AreEqual(sizeof(long), endOffset - storedOffset);
109 }
110
111 [FlatBuffersTestMethod]
112 public void FlatBufferBuilder_WithForceDefaults_WhenAddULong_AndDefaultValue_OffsetIncreasesBySize()
113 {
114 var fbb = CreateBuffer();
115 var storedOffset = fbb.Offset;
116 fbb.AddUlong(0, 0, 0);
117 var endOffset = fbb.Offset;
118 Assert.AreEqual(sizeof(ulong), endOffset - storedOffset);
119 }
120
121 [FlatBuffersTestMethod]
122 public void FlatBufferBuilder_WithForceDefaults_WhenAddFloat_AndDefaultValue_OffsetIncreasesBySize()
123 {
124 var fbb = CreateBuffer();
125 var storedOffset = fbb.Offset;
126 fbb.AddFloat(0, 0, 0);
127 var endOffset = fbb.Offset;
128 Assert.AreEqual(sizeof(float), endOffset - storedOffset);
129 }
130
131 [FlatBuffersTestMethod]
132 public void FlatBufferBuilder_WithForceDefaults_WhenAddDouble_AndDefaultValue_OffsetIncreasesBySize()
133 {
134 var fbb = CreateBuffer();
135 var storedOffset = fbb.Offset;
136 fbb.AddDouble(0, 0, 0);
137 var endOffset = fbb.Offset;
138 Assert.AreEqual(sizeof(double), endOffset - storedOffset);
139 }
140
141 [FlatBuffersTestMethod]
142 public void FlatBufferBuilder_WhenAddBool_AndDefaultValue_OffsetIsUnchanged()
143 {
144 var fbb = CreateBuffer(false);
145 var storedOffset = fbb.Offset;
146 fbb.AddBool(0, false, false);
147 var endOffset = fbb.Offset;
148 Assert.AreEqual(endOffset, storedOffset);
149 }
150
151 [FlatBuffersTestMethod]
152 public void FlatBufferBuilder_WhenAddSByte_AndDefaultValue_OffsetIsUnchanged()
153 {
154 var fbb = CreateBuffer(false);
155 var storedOffset = fbb.Offset;
156 fbb.AddSbyte(0, 0, 0);
157 var endOffset = fbb.Offset;
158 Assert.AreEqual(endOffset, storedOffset);
159 }
160
161 [FlatBuffersTestMethod]
162 public void FlatBufferBuilder_WhenAddByte_AndDefaultValue_OffsetIsUnchanged()
163 {
164 var fbb = CreateBuffer(false);
165 var storedOffset = fbb.Offset;
166 fbb.AddByte(0, 0, 0);
167 var endOffset = fbb.Offset;
168 Assert.AreEqual(endOffset, storedOffset);
169 }
170
171 [FlatBuffersTestMethod]
172 public void FlatBufferBuilder_WhenAddShort_AndDefaultValue_OffsetIsUnchanged()
173 {
174 var fbb = CreateBuffer(false);
175 var storedOffset = fbb.Offset;
176 fbb.AddShort(0, 0, 0);
177 var endOffset = fbb.Offset;
178 Assert.AreEqual(endOffset, storedOffset);
179 }
180
181 [FlatBuffersTestMethod]
182 public void FlatBufferBuilder_WhenAddUShort_AndDefaultValue_OffsetIsUnchanged()
183 {
184 var fbb = CreateBuffer(false);
185 var storedOffset = fbb.Offset;
186 fbb.AddUshort(0, 0, 0);
187 var endOffset = fbb.Offset;
188 Assert.AreEqual(endOffset, storedOffset);
189 }
190
191 [FlatBuffersTestMethod]
192 public void FlatBufferBuilder_WhenAddInt_AndDefaultValue_OffsetIsUnchanged()
193 {
194 var fbb = CreateBuffer(false);
195 var storedOffset = fbb.Offset;
196 fbb.AddInt(0, 0, 0);
197 var endOffset = fbb.Offset;
198 Assert.AreEqual(endOffset, storedOffset);
199 }
200
201 [FlatBuffersTestMethod]
202 public void FlatBufferBuilder_WhenAddUInt_AndDefaultValue_OffsetIsUnchanged()
203 {
204 var fbb = CreateBuffer(false);
205 var storedOffset = fbb.Offset;
206 fbb.AddUint(0, 0, 0);
207 var endOffset = fbb.Offset;
208 Assert.AreEqual(endOffset, storedOffset);
209 }
210
211 [FlatBuffersTestMethod]
212 public void FlatBufferBuilder_WhenAddLong_AndDefaultValue_OffsetIsUnchanged()
213 {
214 var fbb = CreateBuffer(false);
215 var storedOffset = fbb.Offset;
216 fbb.AddLong(0, 0, 0);
217 var endOffset = fbb.Offset;
218 Assert.AreEqual(endOffset, storedOffset);
219 }
220
221 [FlatBuffersTestMethod]
222 public void FlatBufferBuilder_WhenAddULong_AndDefaultValue_OffsetIsUnchanged()
223 {
224 var fbb = CreateBuffer(false);
225 var storedOffset = fbb.Offset;
226 fbb.AddUlong(0, 0, 0);
227 var endOffset = fbb.Offset;
228 Assert.AreEqual(endOffset, storedOffset);
229 }
230
231 [FlatBuffersTestMethod]
232 public void FlatBufferBuilder_WhenAddFloat_AndDefaultValue_OffsetIsUnchanged()
233 {
234 var fbb = CreateBuffer(false);
235 var storedOffset = fbb.Offset;
236 fbb.AddFloat(0, 0, 0);
237 var endOffset = fbb.Offset;
238 Assert.AreEqual(endOffset, storedOffset);
239 }
240
241 [FlatBuffersTestMethod]
242 public void FlatBufferBuilder_WhenAddDouble_AndDefaultValue_OffsetIsUnchanged()
243 {
244 var fbb = CreateBuffer(false);
245 var storedOffset = fbb.Offset;
246 fbb.AddDouble(0, 0, 0);
247 var endOffset = fbb.Offset;
248 Assert.AreEqual(endOffset, storedOffset);
249 }
250
251 [FlatBuffersTestMethod]
252 public void FlatBufferBuilder_WhenAddNullableBool_OffsetIsUnchanged()
253 {
254 var fbb = CreateBuffer(false);
255 var storedOffset = fbb.Offset;
256 fbb.AddBool(0, null);
257 var endOffset = fbb.Offset;
258 Assert.AreEqual(endOffset, storedOffset);
259 }
260
261 [FlatBuffersTestMethod]
262 public void FlatBufferBuilder_WhenAddNullableSbyte_OffsetIsUnchanged()
263 {
264 var fbb = CreateBuffer(false);
265 var storedOffset = fbb.Offset;
266 fbb.AddSbyte(0, null);
267 var endOffset = fbb.Offset;
268 Assert.AreEqual(endOffset, storedOffset);
269 }
270
271 [FlatBuffersTestMethod]
272 public void FlatBufferBuilder_WhenAddNullableByte_OffsetIsUnchanged()
273 {
274 var fbb = CreateBuffer(false);
275 var storedOffset = fbb.Offset;
276 fbb.AddByte(0, null);
277 var endOffset = fbb.Offset;
278 Assert.AreEqual(endOffset, storedOffset);
279 }
280
281 [FlatBuffersTestMethod]
282 public void FlatBufferBuilder_WhenAddNullableShort_OffsetIsUnchanged()
283 {
284 var fbb = CreateBuffer(false);
285 var storedOffset = fbb.Offset;
286 fbb.AddShort(0, null);
287 var endOffset = fbb.Offset;
288 Assert.AreEqual(endOffset, storedOffset);
289 }
290
291 [FlatBuffersTestMethod]
292 public void FlatBufferBuilder_WhenAddNullableUShort_OffsetIsUnchanged()
293 {
294 var fbb = CreateBuffer(false);
295 var storedOffset = fbb.Offset;
296 fbb.AddUshort(0, null);
297 var endOffset = fbb.Offset;
298 Assert.AreEqual(endOffset, storedOffset);
299 }
300
301 [FlatBuffersTestMethod]
302 public void FlatBufferBuilder_WhenAddNullableInt_OffsetIsUnchanged()
303 {
304 var fbb = CreateBuffer(false);
305 var storedOffset = fbb.Offset;
306 fbb.AddInt(0, null);
307 var endOffset = fbb.Offset;
308 Assert.AreEqual(endOffset, storedOffset);
309 }
310
311 [FlatBuffersTestMethod]
312 public void FlatBufferBuilder_WhenAddNullableUInt_OffsetIsUnchanged()
313 {
314 var fbb = CreateBuffer(false);
315 var storedOffset = fbb.Offset;
316 fbb.AddUint(0, null);
317 var endOffset = fbb.Offset;
318 Assert.AreEqual(endOffset, storedOffset);
319 }
320
321 [FlatBuffersTestMethod]
322 public void FlatBufferBuilder_WhenAddNullableLong_OffsetIsUnchanged()
323 {
324 var fbb = CreateBuffer(false);
325 var storedOffset = fbb.Offset;
326 fbb.AddLong(0, null);
327 var endOffset = fbb.Offset;
328 Assert.AreEqual(endOffset, storedOffset);
329 }
330
331 [FlatBuffersTestMethod]
332 public void FlatBufferBuilder_WhenAddNullableULong_OffsetIsUnchanged()
333 {
334 var fbb = CreateBuffer(false);
335 var storedOffset = fbb.Offset;
336 fbb.AddUlong(0, null);
337 var endOffset = fbb.Offset;
338 Assert.AreEqual(endOffset, storedOffset);
339 }
340
341 [FlatBuffersTestMethod]
342 public void FlatBufferBuilder_WhenAddNullableFloat_OffsetIsUnchanged()
343 {
344 var fbb = CreateBuffer(false);
345 var storedOffset = fbb.Offset;
346 fbb.AddFloat(0, null);
347 var endOffset = fbb.Offset;
348 Assert.AreEqual(endOffset, storedOffset);
349 }
350
351 [FlatBuffersTestMethod]
352 public void FlatBufferBuilder_WhenAddNullableDouble_OffsetIsUnchanged()
353 {
354 var fbb = CreateBuffer(false);
355 var storedOffset = fbb.Offset;
356 fbb.AddDouble(0, null);
357 var endOffset = fbb.Offset;
358 Assert.AreEqual(endOffset, storedOffset);
359 }
360
361 [FlatBuffersTestMethod]
362 public void FlatBufferBuilder_WhenAddNullableBool_OffsetIsChangedBySize()
363 {
364 var fbb = CreateBuffer(false);
365 var storedOffset = fbb.Offset;
366 fbb.AddBool(0, true);
367 var endOffset = fbb.Offset;
368 Assert.AreEqual(sizeof(bool), endOffset - storedOffset);
369 }
370
371 [FlatBuffersTestMethod]
372 public void FlatBufferBuilder_WhenAddNullableSbyte_OffsetIsChangedBySize()
373 {
374 var fbb = CreateBuffer(false);
375 var storedOffset = fbb.Offset;
376 fbb.AddSbyte(0, 1);
377 var endOffset = fbb.Offset;
378 Assert.AreEqual(sizeof(sbyte), endOffset - storedOffset);
379 }
380
381 [FlatBuffersTestMethod]
382 public void FlatBufferBuilder_WhenAddNullableByte_OffsetIsChangedBySize()
383 {
384 var fbb = CreateBuffer(false);
385 var storedOffset = fbb.Offset;
386 fbb.AddByte(0, 1);
387 var endOffset = fbb.Offset;
388 Assert.AreEqual(sizeof(byte), endOffset - storedOffset);
389 }
390
391 [FlatBuffersTestMethod]
392 public void FlatBufferBuilder_WhenAddNullableShort_OffsetIsChangedBySize()
393 {
394 var fbb = CreateBuffer(false);
395 var storedOffset = fbb.Offset;
396 fbb.AddShort(0, 1);
397 var endOffset = fbb.Offset;
398 Assert.AreEqual(sizeof(short), endOffset - storedOffset);
399 }
400
401 [FlatBuffersTestMethod]
402 public void FlatBufferBuilder_WhenAddNullableUShort_OffsetIsChangedBySize()
403 {
404 var fbb = CreateBuffer(false);
405 var storedOffset = fbb.Offset;
406 fbb.AddUshort(0, 1);
407 var endOffset = fbb.Offset;
408 Assert.AreEqual(sizeof(ushort), endOffset - storedOffset);
409 }
410
411 [FlatBuffersTestMethod]
412 public void FlatBufferBuilder_WhenAddNullableInt_OffsetIsChangedBySize()
413 {
414 var fbb = CreateBuffer(false);
415 var storedOffset = fbb.Offset;
416 fbb.AddInt(0, 1);
417 var endOffset = fbb.Offset;
418 Assert.AreEqual(sizeof(int), endOffset - storedOffset);
419 }
420
421 [FlatBuffersTestMethod]
422 public void FlatBufferBuilder_WhenAddNullableUInt_OffsetIsChangedBySize()
423 {
424 var fbb = CreateBuffer(false);
425 var storedOffset = fbb.Offset;
426 fbb.AddUint(0, 1);
427 var endOffset = fbb.Offset;
428 Assert.AreEqual(sizeof(uint), endOffset - storedOffset);
429 }
430
431 [FlatBuffersTestMethod]
432 public void FlatBufferBuilder_WhenAddNullableLong_OffsetIsChangedBySize()
433 {
434 var fbb = CreateBuffer(false);
435 var storedOffset = fbb.Offset;
436 fbb.AddLong(0, 1);
437 var endOffset = fbb.Offset;
438 Assert.AreEqual(sizeof(long), endOffset - storedOffset);
439 }
440
441 [FlatBuffersTestMethod]
442 public void FlatBufferBuilder_WhenAddNullableULong_OffsetIsChangedBySize()
443 {
444 var fbb = CreateBuffer(false);
445 var storedOffset = fbb.Offset;
446 fbb.AddUlong(0, 1);
447 var endOffset = fbb.Offset;
448 Assert.AreEqual(sizeof(ulong), endOffset - storedOffset);
449 }
450
451 [FlatBuffersTestMethod]
452 public void FlatBufferBuilder_WhenAddNullableFloat_OffsetIsChangedBySize()
453 {
454 var fbb = CreateBuffer(false);
455 var storedOffset = fbb.Offset;
456 fbb.AddFloat(0, 1.0F);
457 var endOffset = fbb.Offset;
458 Assert.AreEqual(sizeof(float), endOffset - storedOffset);
459 }
460
461 [FlatBuffersTestMethod]
462 public void FlatBufferBuilder_WhenAddNullableDouble_OffsetIsChangedBySize()
463 {
464 var fbb = CreateBuffer(false);
465 var storedOffset = fbb.Offset;
466 fbb.AddDouble(0, 1.0);
467 var endOffset = fbb.Offset;
468 Assert.AreEqual(sizeof(double), endOffset - storedOffset);
469 }
470
471 [FlatBuffersTestMethod]
472 public void FlatBufferBuilder_Add_Array_Float()
473 {
474 var fbb = CreateBuffer(false);
475 var storedOffset = fbb.Offset;
476
477 const int len = 9;
478
479 // Construct the data array
480 var data = new float[len];
481 data[0] = 1.0079F;
482 data[1] = 4.0026F;
483 data[2] = 6.941F;
484 data[3] = 9.0122F;
485 data[4] = 10.811F;
486 data[5] = 12.0107F;
487 data[6] = 14.0067F;
488 data[7] = 15.9994F;
489 data[8] = 18.9984F;
490
491 fbb.Add(data);
492 var endOffset = fbb.Offset;
493 Assert.AreEqual(endOffset, storedOffset + sizeof(float) * data.Length);
494 }
495
496 [FlatBuffersTestMethod]
497 public void FlatBufferBuilder_Add_Array_Bool()
498 {
499 var fbb = CreateBuffer(false);
500 var storedOffset = fbb.Offset;
501
502 const int len = 9;
503
504 // Construct the data array
505 var data = new bool[len];
506 data[0] = true;
507 data[1] = true;
508 data[2] = false;
509 data[3] = true;
510 data[4] = false;
511 data[5] = true;
512 data[6] = true;
513 data[7] = true;
514 data[8] = false;
515
516 fbb.Add(data);
517 var endOffset = fbb.Offset;
518 Assert.AreEqual(endOffset, storedOffset + sizeof(bool) * data.Length);
519 }
520
521 [FlatBuffersTestMethod]
522 public void FlatBufferBuilder_Add_Array_Double()
523 {
524 var fbb = CreateBuffer(false);
525 var storedOffset = fbb.Offset;
526
527 const int len = 9;
528
529 // Construct the data array
530 var data = new double[len];
531 data[0] = 1.0079;
532 data[1] = 4.0026;
533 data[2] = 6.941;
534 data[3] = 9.0122;
535 data[4] = 10.811;
536 data[5] = 12.0107;
537 data[6] = 14.0067;
538 data[7] = 15.9994;
539 data[8] = 18.9984;
540
541 fbb.Add(data);
542 var endOffset = fbb.Offset;
543 Assert.AreEqual(endOffset, storedOffset + sizeof(double) * data.Length);
544 }
545
546 [FlatBuffersTestMethod]
547 public void FlatBufferBuilder_Add_Array_Null_Throws()
548 {
549 var fbb = CreateBuffer(false);
550
551 // Construct the data array
552 float[] data = null;
553
554 Assert.Throws<ArgumentNullException>(() => fbb.Add(data));
555 }
556
557 [FlatBuffersTestMethod]
558 public unsafe void FlatBufferBuilder_Add_Array_UnsupportedType_Throws()
559 {
560 var fbb = CreateBuffer(false);
561
562 var storedOffset = fbb.Offset;
563
564 // Construct the data array
565 var data = new DummyStruct[10];
566 Assert.Throws<ArgumentException>(() => fbb.Add(data));
567 }
568
569 [FlatBuffersTestMethod]
570 public void FlatBufferBuilder_Add_Array_Empty_Noop()
571 {
572 var fbb = CreateBuffer(false);
573
574 var storedOffset = fbb.Offset;
575
576 // Construct an empty data array
577 float[] data = new float[0];
578 fbb.Add(data);
579
580 // Make sure the offset didn't change since nothing
581 // was really added
582 var endOffset = fbb.Offset;
583 Assert.AreEqual(endOffset, storedOffset);
584 }
585
586 [FlatBuffersTestMethod]
587 public void FlatBufferBuilder_Add_ArraySegment_Default_Throws()
588 {
589 var fbb = CreateBuffer(false);
590
591 // Construct the data array
592 ArraySegment<float> data = default;
593
594 Assert.Throws<ArgumentNullException>(() => fbb.Add(data));
595 }
596
597 [FlatBuffersTestMethod]
598 public unsafe void FlatBufferBuilder_Add_ArraySegment_UnsupportedType_Throws()
599 {
600 var fbb = CreateBuffer(false);
601
602 var storedOffset = fbb.Offset;
603
604 // Construct the data array
605 var array = new DummyStruct[10];
606 var data = new ArraySegment<DummyStruct>(array);
607 Assert.Throws<ArgumentException>(() => fbb.Add(data));
608 }
609
610 [FlatBuffersTestMethod]
611 public void FlatBufferBuilder_Add_ArraySegment_Empty_Noop()
612 {
613 var fbb = CreateBuffer(false);
614
615 var storedOffset = fbb.Offset;
616
617 // Construct the data array
618 var array = new float[10];
619 var data = new ArraySegment<float>(array, 5, 0);
620 fbb.Add(data);
621
622 // Make sure the offset didn't change since nothing
623 // was really added
624 var endOffset = fbb.Offset;
625 Assert.AreEqual(endOffset, storedOffset);
626 }
627
628 [FlatBuffersTestMethod]
629 public void FlatBufferBuilder_Add_IntPtr_Zero_Throws()
630 {
631 var fbb = CreateBuffer(false);
632
633 // Construct the data array
634 var data = IntPtr.Zero;
635 var length = 100;
636
637 Assert.Throws<ArgumentNullException>(() => fbb.Add<float>(data, length));
638 }
639
640 [FlatBuffersTestMethod]
641 public unsafe void FlatBufferBuilder_Add_IntPtr_SizeNegative_Throws()
642 {
643 var fbb = CreateBuffer(false);
644
645 // Construct the data array
646 var array = new float[10];
647 fixed(float* ptr = array)
648 {
649 var data = (IntPtr)ptr;
650 var length = -1;
651 Assert.Throws<ArgumentOutOfRangeException>(() => fbb.Add<float>(data, length));
652 }
653 }
654
655 [FlatBuffersTestMethod]
656 public void FlatBufferBuilder_Add_IntPtr_Zero_Empty_Noop()
657 {
658 var fbb = CreateBuffer(false);
659
660 var storedOffset = fbb.Offset;
661
662 // Construct the data array
663 var data = IntPtr.Zero;
664 var length = 0;
665
666 fbb.Add<float>(data, length);
667
668 // make sure that a length of 0 doesn't throw also if ptr is Zero as well
669 // and that nothing was really added
670 var endOffset = fbb.Offset;
671 Assert.AreEqual(endOffset, storedOffset);
672 }
673
674 [FlatBuffersTestMethod]
675 public unsafe void FlatBufferBuilder_Add_IntPtr_Empty_Noop()
676 {
677 var fbb = CreateBuffer(false);
678
679 var storedOffset = fbb.Offset;
680
681 // Construct the data array
682 var array = new float[10];
683 fixed(float* ptr = array)
684 {
685 var data = (IntPtr)ptr;
686 var length = 0;
687 fbb.Add<float>(data, length);
688 }
689
690 // Make sure the offset didn't change since nothing
691 // was really added
692 var endOffset = fbb.Offset;
693 Assert.AreEqual(endOffset, storedOffset);
694 }
695
696 [FlatBuffersTestMethod]
697 public unsafe void FlatBufferBuilder_Add_IntPtr_SizeInBytesNotMatchingDataType_Throws()
698 {
699 var fbb = CreateBuffer(false);
700
701 var storedOffset = fbb.Offset;
702
703 // Construct the data array
704 var array = new float[10];
705 fixed(float* ptr = array)
706 {
707 const int invalidBytes = 1;
708 var data = (IntPtr)ptr;
709 // add some invalid bytes to the length
710 var length = 2 * sizeof(float) + invalidBytes;
711
712 Assert.Throws<ArgumentException>(() => fbb.Add<float>(data, length));
713 }
714 }
715
716 [FlatBuffersTestMethod]
717 public unsafe void FlatBufferBuilder_Add_IntPtr_UnsupportedType_Throws()
718 {
719 var fbb = CreateBuffer(false);
720
721 var storedOffset = fbb.Offset;
722
723 // Construct the data array
724 var array = new DummyStruct[10];
725 fixed(DummyStruct* ptr = array)
726 {
727 var data = (IntPtr)ptr;
728 var length = 10 * sizeof(DummyStruct);
729
730 Assert.Throws<ArgumentException>(() => fbb.Add<DummyStruct>(data, length));
731 }
732 }
733
734 private struct DummyStruct
735 {
736 int value;
737 }
738
739 [FlatBuffersTestMethod]
740 public void FlatBufferBuilder_Add_null_String()
741 {
742 var fbb = new FlatBufferBuilder(16);
743 string s = null;
744 Assert.AreEqual(fbb.CreateSharedString(s).Value, 0);
745 Assert.AreEqual(fbb.CreateString(s).Value, 0);
746 }
747
748 [FlatBuffersTestMethod]
749 public void FlatBufferBuilder_Empty_Builder()
750 {
751 var fbb = new FlatBufferBuilder(16);
752 var str = "Hello";
753 var flatbuffer = "Flatbuffers!";
754 var strOffset = fbb.CreateSharedString(str);
755 var flatbufferOffset = fbb.CreateSharedString(flatbuffer);
756 fbb.Clear();
757 var flatbufferOffset2 = fbb.CreateSharedString(flatbuffer);
758 var strOffset2 = fbb.CreateSharedString(str);
759 Assert.IsFalse(strOffset.Value == strOffset2.Value);
760 Assert.IsFalse(flatbufferOffset.Value == flatbufferOffset2.Value);
761 }
762 }
763}
View as plain text