1<?php
2// manual load for testing. please use PSR style autoloader when you use flatbuffers.
3require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "Constants.php"));
4require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "ByteBuffer.php"));
5require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "FlatbufferBuilder.php"));
6require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "Table.php"));
7require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "Struct.php"));
8foreach (glob(join(DIRECTORY_SEPARATOR, array(dirname(__FILE__), "MyGame", "Example", "*.php"))) as $file) {
9 require $file;
10}
11
12function main()
13{
14 /// Begin Test
15 $assert = new Assert();
16
17 // First, let's test reading a FlatBuffer generated by C++ code:
18 // This file was generated from monsterdata_test.json
19
20 // Now test it:
21 $data = file_get_contents('monsterdata_test.mon');
22 $bb = Google\FlatBuffers\ByteBuffer::wrap($data);
23 test_buffer($assert, $bb);
24
25 // Second, let's create a FlatBuffer from scratch in JavaScript, and test it also.
26 // We use an initial size of 1 to exercise the reallocation algorithm,
27 // normally a size larger than the typical FlatBuffer you generate would be
28 // better for performance.
29 $fbb = new Google\FlatBuffers\FlatBufferBuilder(1);
30
31 // We set up the same values as monsterdata.json:
32 $str = $fbb->createString("MyMonster");
33 $name = $fbb->createString('Fred');
34 \MyGame\Example\Monster::startMonster($fbb);
35 \MyGame\Example\Monster::addName($fbb, $name);
36 $enemy = \MyGame\Example\Monster::endMonster($fbb);
37
38 $inv = \MyGame\Example\Monster::CreateInventoryVector($fbb, array(0, 1, 2, 3, 4));
39
40 $fred = $fbb->createString('Fred');
41 \MyGame\Example\Monster::StartMonster($fbb);
42 \MyGame\Example\Monster::AddName($fbb, $fred);
43 $mon2 = \MyGame\Example\Monster::EndMonster($fbb);
44
45 \MyGame\Example\Monster::StartTest4Vector($fbb, 2);
46 \MyGame\Example\Test::CreateTest($fbb, 10, 20);
47 \MyGame\Example\Test::CreateTest($fbb, 30, 40);
48 $test4 = $fbb->endVector();
49
50 $testArrayOfString = \MyGame\Example\Monster::CreateTestarrayofstringVector($fbb, array(
51 $fbb->createString('test1'),
52 $fbb->createString('test2')
53 ));
54
55 \MyGame\Example\Monster::StartMonster($fbb);
56 \MyGame\Example\Monster::AddPos($fbb, \MyGame\Example\Vec3::CreateVec3($fbb,
57 1.0, 2.0, 3.0, //float
58 3.0, // double
59 \MyGame\Example\Color::Green,
60 5, //short
61 6));
62 \MyGame\Example\Monster::AddHp($fbb, 80);
63 \MyGame\Example\Monster::AddName($fbb, $str);
64 \MyGame\Example\Monster::AddInventory($fbb, $inv);
65 \MyGame\Example\Monster::AddTestType($fbb, \MyGame\Example\Any::Monster);
66 \MyGame\Example\Monster::AddTest($fbb, $mon2);
67 \MyGame\Example\Monster::AddTest4($fbb, $test4);
68 \MyGame\Example\Monster::AddTestarrayofstring($fbb, $testArrayOfString);
69 \MyGame\Example\Monster::AddEnemy($fbb, $enemy);
70 \MyGame\Example\Monster::AddTestbool($fbb, true);
71 $mon = \MyGame\Example\Monster::EndMonster($fbb);
72
73 \MyGame\Example\Monster::FinishMonsterBuffer($fbb, $mon);
74
75 // Test it:
76 test_buffer($assert, $fbb->dataBuffer());
77
78 testByteBuffer($assert);
79 fuzzTest1($assert);
80// testUnicode($assert);
81
82 echo 'FlatBuffers php test: completed successfully' . PHP_EOL;
83}
84
85try {
86 main();
87 exit(0);
88} catch(Exception $e) {
89 printf("Fatal error: Uncaught exception '%s' with message '%s. in %s:%d\n", get_class($e), $e->getMessage(), $e->getFile(), $e->getLine());
90 printf("Stack trace:\n");
91 echo $e->getTraceAsString() . PHP_EOL;
92 printf(" thrown in in %s:%d\n", $e->getFile(), $e->getLine());
93
94 die(-1);
95}
96
97function test_buffer(Assert $assert, Google\FlatBuffers\ByteBuffer $bb) {
98
99 $assert->ok(MyGame\Example\Monster::MonsterBufferHasIdentifier($bb));
100 $monster = \MyGame\Example\Monster::GetRootAsMonster($bb);
101
102 $assert->strictEqual($monster->GetHp(), 80);
103 $assert->strictEqual($monster->GetMana(), 150); // default
104
105 $assert->strictEqual($monster->GetName(), 'MyMonster');
106
107 $pos = $monster->GetPos();
108 $assert->strictEqual($pos->GetX(), 1.0);
109 $assert->strictEqual($pos->GetY(), 2.0);
110 $assert->strictEqual($pos->GetZ(), 3.0);
111
112 $assert->Equal($pos->GetTest1(), 3.0);
113 $assert->strictEqual($pos->GetTest2(), \MyGame\Example\Color::Green);
114
115 $t = $pos->GetTest3();
116 $assert->strictEqual($t->GetA(), 5);
117 $assert->strictEqual($t->GetB(), 6);
118 $assert->strictEqual($monster->GetTestType(), \MyGame\Example\Any::Monster);
119
120 $monster2 = new \MyGame\Example\Monster();
121 $assert->strictEqual($monster->GetTest($monster2) != null, true);
122 $assert->strictEqual($monster2->GetName(), 'Fred');
123
124 $assert->strictEqual($monster->GetInventoryLength(), 5);
125 $invsum = 0;
126 for ($i = 0; $i < $monster->GetInventoryLength(); $i++) {
127 $invsum += $monster->GetInventory($i);
128 }
129 $assert->strictEqual($invsum, 10);
130
131 $assert->strictEqual(bin2hex($monster->GetInventoryBytes()), "0001020304");
132
133 $test_0 = $monster->GetTest4(0);
134 $test_1 = $monster->GetTest4(1);
135 $assert->strictEqual($monster->GetTest4Length(), 2);
136 $assert->strictEqual($test_0->GetA() + $test_0->GetB() + $test_1->GetA() + $test_1->GetB(), 100);
137
138 $assert->strictEqual($monster->GetTestarrayofstringLength(), 2);
139 $assert->strictEqual($monster->GetTestarrayofstring(0), 'test1');
140 $assert->strictEqual($monster->GetTestarrayofstring(1), 'test2');
141
142 $fred = $monster->getEnemy();
143 $assert->Equal('Fred', $fred->getName());
144
145 $assert->strictEqual($monster->GetTestbool(), true);
146}
147
148//function testUnicode(Assert $assert) {
149// // missing unicode_test.mon, implemented later
150// $correct = file_get_contents('unicode_test.mon');
151// $json = json_decode(file_get_contents('unicode_test.json'));
152//
153// // Test reading
154// $bb = flatbuffers\ByteBuffer::Wrap($correct);
155// $monster = \MyGame\Example\Monster::GetRootAsMonster($bb);
156// $assert->strictEqual($monster->GetName(), $json["name"]);
157//
158// //$assert->deepEqual(new Buffer(monster.name(flatbuffers.Encoding.UTF8_BYTES)), new Buffer(json.name));
159// //assert.strictEqual(monster.testarrayoftablesLength(), json.testarrayoftables.length);
160// foreach ($json["testarrayoftables"]as $i => $table) {
161// $value = $monster->GetTestArrayOfTables($i);
162// $assert->strictEqual($value->GetName(), $table["name"]);
163// //assert.deepEqual(new Buffer(value.name(flatbuffers.Encoding.UTF8_BYTES)), new Buffer(table.name));
164// }
165// $assert->strictEqual($monster->GetTestarrayofstringLength(), $json["testarrayofstring"]["length"]);
166// foreach ($json["testarrayofstring"] as $i => $string) {
167// $assert->strictEqual($monster->GetTestarrayofstring($i), $string);
168// //assert.deepEqual(new Buffer(monster.testarrayofstring(i, flatbuffers.Encoding.UTF8_BYTES)), new Buffer(string));
169// }
170//
171// // Test writing
172// $fbb = new FlatBuffers\FlatBufferBuilder(1);
173// $name = $fbb->CreateString($json["name"]);
174// $testarrayoftablesOffsets = array_map(function($table) use($fbb) {
175// $name = $fbb->CreateString($table["name"]);
176// \MyGame\Example\Monster::StartMonster($fbb);
177// \MyGame\Example\Monster::AddName($fbb, $name);
178// return \MyGame\Example\Monster::EndMonster($fbb);
179// }, $json["testarrayoftables"]);
180// $testarrayoftablesOffset = \MyGame\Example\Monster::CreateTestarrayoftablesVector($fbb,
181// $testarrayoftablesOffsets);
182//// $testarrayofstringOffset = \MyGame\Example\Monster::CreateTestarrayofstringVector($fbb,
183//// $json["testarrayofstring"].map(function(string) { return fbb.createString(string); }));
184//
185// \MyGame\Example\Monster::startMonster($fbb);
186// \MyGame\Example\Monster::addTestarrayofstring($fbb, $testarrayoftablesOffset);
187// \MyGame\Example\Monster::addTestarrayoftables($fbb, $testarrayoftablesOffset);
188// \MyGame\Example\Monster::addName($fbb, $name);
189// \MyGame\Example\Monster::finishMonsterBuffer($fbb, \MyGame\Example\Monster::endMonster($fbb));
190// //;assert.deepEqual(new Buffer(fbb.asUint8Array()), correct);
191//}
192
193// Low level stress/fuzz test: serialize/deserialize a variety of
194// different kinds of data in different combinations
195function fuzzTest1(Assert $assert)
196{
197
198 // Values we're testing against: chosen to ensure no bits get chopped
199 // off anywhere, and also be different from eachother.
200 $bool_val = true;
201 $char_val = -127; // 0x81
202 $uchar_val = 0xFF;
203 $short_val = -32222; // 0x8222;
204 $ushort_val = 0xFEEE;
205 $int_val = 0x7fffffff | 0;
206 // for now
207 $uint_val = 1;
208 $long_val = 2;
209 $ulong_val = 3;
210
211// var uint_val = 0xFDDDDDDD;
212// var long_val = new flatbuffers.Long(0x44444444, 0x84444444);
213// var ulong_val = new flatbuffers.Long(0xCCCCCCCC, 0xFCCCCCCC);
214
215 $float_val = 3.14159;
216 $double_val = 3.14159265359;
217
218 $test_values_max = 11;
219 $fields_per_object = 4;
220 // current implementation is not good at encoding.
221 $num_fuzz_objects = 1000;
222 $builder = new Google\FlatBuffers\FlatBufferBuilder(1);
223
224 // can't use same implementation due to PHP_INTMAX overflow issue.
225 // we use mt_rand function to reproduce fuzzy test.
226 mt_srand(48271);
227 $objects = array();
228 // Generate num_fuzz_objects random objects each consisting of
229 // fields_per_object fields, each of a random type.
230 for ($i = 0; $i < $num_fuzz_objects; $i++) {
231 $builder->startObject($fields_per_object);
232 for ($f = 0; $f < $fields_per_object; $f++) {
233 $choice = mt_rand() % $test_values_max;
234 switch ($choice) {
235 case 0:
236 $builder->addBoolX($f, $bool_val, 0);
237 break;
238 case 1:
239 $builder->addByteX($f, $char_val, 0);
240 break;
241 case 2:
242 $builder->addSbyteX($f, $uchar_val, 0);
243 break;
244 case 3:
245 $builder->addShortX($f, $short_val, 0);
246 break;
247 case 4:
248 $builder->addUshortX($f, $ushort_val, 0);
249 break;
250 case 5:
251 $builder->addIntX($f, $int_val, 0);
252 break;
253 case 6:
254 $builder->addUintX($f, $uint_val, 0);
255 break;
256 case 7:
257 $builder->addLongX($f, $long_val, 0);
258 break;
259 case 8:
260 $builder->addUlongX($f, $ulong_val, 0);
261 break;
262 case 9:
263 $builder->addFloatX($f, $float_val, 0);
264 break;
265 case 10:
266 $builder->addDoubleX($f, $double_val, 0);
267 break;
268 }
269 }
270 $objects[] = $builder->endObject();
271 }
272 $builder->prep(8, 0); // Align whole buffer.
273
274 mt_srand(48271); // Reset
275 $builder->finish($objects[count($objects) - 1]);
276
277 $view = Google\FlatBuffers\ByteBuffer::wrap($builder->sizedByteArray());
278 for ($i = 0; $i < $num_fuzz_objects; $i++) {
279 $offset = $view->capacity() - $objects[$i];
280 for ($f = 0; $f < $fields_per_object; $f++) {
281 $choice = mt_rand() % $test_values_max;
282 $vtable_offset = fieldIndexToOffset($f);
283 $vtable = $offset - $view->getInt($offset);
284 $assert->ok($vtable_offset < $view->getShort($vtable));
285 $field_offset = $offset + $view->getShort($vtable + $vtable_offset);
286 switch ($choice) {
287 case 0:
288 $assert->strictEqual(!!$view->getBool($field_offset), $bool_val);
289 break;
290 case 1:
291 $assert->strictEqual($view->getSbyte($field_offset), $char_val);
292 break;
293 case 2:
294 $assert->strictEqual($view->getByte($field_offset), $uchar_val);
295 break;
296 case 3:
297 $assert->strictEqual($view->getShort($field_offset), $short_val);
298 break;
299 case 4:
300 $assert->strictEqual($view->getUShort($field_offset), $ushort_val);
301 break;
302 case 5:
303 $assert->strictEqual($view->getInt($field_offset), $int_val);
304 break;
305 case 6:
306 $assert->strictEqual($view->getUint($field_offset), $uint_val);
307 break;
308 case 7:
309 if (PHP_INT_SIZE <= 4) break;
310 $assert->strictEqual($view->getLong($field_offset), $long_val);
311 break;
312 case 8:
313 if (PHP_INT_SIZE <= 4) break;
314 $assert->strictEqual($view->getUlong($field_offset), $ulong_val);
315 break;
316 case 9:
317 $assert->strictEqual(floor($view->getFloat($field_offset)), floor($float_val));
318 break;
319 case 10:
320 $assert->strictEqual($view->getDouble($field_offset), $double_val);
321 break;
322 }
323 }
324 }
325}
326
327function fieldIndexToOffset($field_id) {
328 // Should correspond to what EndTable() below builds up.
329 $fixed_fields = 2; // Vtable size and Object Size.
330 return ($field_id + $fixed_fields) * 2;
331}
332
333function testByteBuffer(Assert $assert) {
334
335 //Test: ByteBuffer_Length_MatchesBufferLength
336 $buffer = str_repeat("\0", 100);
337 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
338 $assert->Equal($uut->capacity(), strlen($buffer));
339
340 //Test: ByteBuffer_PutBytePopulatesBufferAtZeroOffset
341 $buffer = "\0";
342 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
343 $uut->putByte(0, "\x63"); // 99
344 $assert->Equal("\x63", $uut->_buffer[0]); // don't share buffer as php user might confuse reference.
345
346 //Test: ByteBuffer_PutByteCannotPutAtOffsetPastLength
347 $buffer = "\0";
348 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
349 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
350 $uut->putByte(1, "\x63"); // 99
351 });
352
353 //Test: ByteBuffer_PutShortPopulatesBufferCorrectly
354 $buffer = str_repeat("\0", 2);
355 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
356 $uut->putShort(0, 1);
357
358 // Ensure Endiannes was written correctly
359 $assert->Equal(chr(0x01), $uut->_buffer[0]);
360 $assert->Equal(chr(0x00), $uut->_buffer[1]);
361
362 $buffer = str_repeat("\0", 2);
363 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
364 $uut->putShort(0, -32768);
365
366 // Ensure Endiannes was written correctly
367 $assert->Equal(chr(0x00), $uut->_buffer[0]);
368 $assert->Equal(chr(0x80), $uut->_buffer[1]);
369
370 //Test: ByteBuffer_PutShortCannotPutAtOffsetPastLength
371 $buffer = "\0";
372 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
373 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
374 $uut->putShort(2, 2); // 99
375 });
376
377 //Test: ByteBuffer_PutShortChecksLength
378 $buffer = "\0";
379 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
380 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
381 $uut->putShort(0, 2); // 99
382 });
383
384 //Test: ByteBuffer_PutShortChecksLengthAndOffset
385 $buffer = str_repeat("\0", 2);
386 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
387 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
388 $uut->putShort(1, 2); // 99
389 });
390
391 //Test: ByteBuffer_PutIntPopulatesBufferCorrectly
392 $buffer = str_repeat("\0", 4);
393 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
394 $uut->putInt(0, 0x0A0B0C0D);
395 $assert->Equal(chr(0x0D), $uut->_buffer[0]);
396 $assert->Equal(chr(0x0C), $uut->_buffer[1]);
397 $assert->Equal(chr(0x0B), $uut->_buffer[2]);
398 $assert->Equal(chr(0x0A), $uut->_buffer[3]);
399
400 $buffer = str_repeat("\0", 4);
401 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
402 $uut->putInt(0, -2147483648);
403 $assert->Equal(chr(0x00), $uut->_buffer[0]);
404 $assert->Equal(chr(0x00), $uut->_buffer[1]);
405 $assert->Equal(chr(0x00), $uut->_buffer[2]);
406 $assert->Equal(chr(0x80), $uut->_buffer[3]);
407
408 //Test: ByteBuffer_PutIntCannotPutAtOffsetPastLength
409 $buffer = str_repeat("\0", 4);
410 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
411 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
412 $uut->putInt(2, 0x0A0B0C0D);
413 });
414
415 //Test: ByteBuffer_PutIntChecksLength
416 $buffer = str_repeat("\0", 1);
417 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
418 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
419 $uut->putInt(0, 0x0A0B0C0D);
420 });
421
422 //Test: ByteBuffer_PutIntChecksLengthAndOffset
423 $buffer = str_repeat("\0", 4);
424 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
425 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
426 $uut->putInt(2, 0x0A0B0C0D);
427 });
428
429 if (PHP_INT_SIZE > 4) {
430 //Test: ByteBuffer_PutLongPopulatesBufferCorrectly
431 $buffer = str_repeat("\0", 8);
432 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
433 $uut->putLong(0, 0x010203040A0B0C0D);
434 $assert->Equal(chr(0x0D), $uut->_buffer[0]);
435 $assert->Equal(chr(0x0C), $uut->_buffer[1]);
436 $assert->Equal(chr(0x0B), $uut->_buffer[2]);
437 $assert->Equal(chr(0x0A), $uut->_buffer[3]);
438 $assert->Equal(chr(0x04), $uut->_buffer[4]);
439 $assert->Equal(chr(0x03), $uut->_buffer[5]);
440 $assert->Equal(chr(0x02), $uut->_buffer[6]);
441 $assert->Equal(chr(0x01), $uut->_buffer[7]);
442
443 //Test: ByteBuffer_PutLongCannotPutAtOffsetPastLength
444 $buffer = str_repeat("\0", 8);
445 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
446 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
447 $uut->putLong(2, 0x010203040A0B0C0D);
448 });
449
450 //Test: ByteBuffer_PutLongCannotPutAtOffsetPastLength
451 $buffer = str_repeat("\0", 1);
452 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
453 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
454 $uut->putLong(0, 0x010203040A0B0C0D);
455 });
456
457
458 //Test: ByteBuffer_PutLongChecksLengthAndOffset
459 $buffer = str_repeat("\0", 8);
460 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
461 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
462 $uut->putLong(2, 0x010203040A0B0C0D);
463 });
464 }
465
466 //Test: ByteBuffer_GetByteReturnsCorrectData
467 $buffer = str_repeat("\0", 1);
468 $buffer[0] = "\x63";
469 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
470 $assert->Equal("\x63", $uut->get(0));
471
472 //Test: ByteBuffer_GetByteChecksOffset
473 $buffer = str_repeat("\0", 1);
474 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
475 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
476 $uut->get(1);
477 });
478
479 //Test: ByteBuffer_GetShortReturnsCorrectData
480 $buffer = str_repeat("\0", 2);
481 $buffer[0] = chr(0x01);
482 $buffer[1] = chr(0x00);
483 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
484 $assert->Equal(1, $uut->getShort(0));
485
486 //Test: ByteBuffer_GetShortReturnsCorrectData (signed value)
487 $buffer = str_repeat("\0", 2);
488 $buffer[0] = chr(0x00);
489 $buffer[1] = chr(0x80);
490 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
491 $assert->Equal(-32768, $uut->getShort(0));
492
493 //Test: ByteBuffer_GetShortChecksOffset
494 $buffer = str_repeat("\0", 2);
495 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
496 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
497 $uut->getShort(2);
498 });
499
500 //Test: ByteBuffer_GetShortChecksLength
501 $buffer = str_repeat("\0", 2);
502 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
503 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
504 $uut->getShort(1);
505 });
506
507 //Test: ByteBuffer_GetIntReturnsCorrectData
508 $buffer = str_repeat("\0", 4);
509 $buffer[0] = chr(0x0D);
510 $buffer[1] = chr(0x0C);
511 $buffer[2] = chr(0x0B);
512 $buffer[3] = chr(0x0A);
513 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
514 $assert->Equal(0x0A0B0C0D, $uut->getInt(0));
515
516 $buffer = str_repeat("\0", 4);
517 $buffer[0] = chr(0x00);
518 $buffer[1] = chr(0x00);
519 $buffer[2] = chr(0x00);
520 $buffer[3] = chr(0x80);
521 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
522 $assert->Equal(-2147483648, $uut->getInt(0));
523
524 //Test: ByteBuffer_GetIntChecksOffset
525 $buffer = str_repeat("\0", 4);
526
527 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
528 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
529 $uut->getInt(4);
530 });
531
532 //Test: ByteBuffer_GetIntChecksLength
533 $buffer = str_repeat("\0", 2);
534 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
535 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
536 $uut->getInt(0);
537 });
538
539 if (PHP_INT_SIZE > 4) {
540 //Test: ByteBuffer_GetLongReturnsCorrectData
541 $buffer = str_repeat("\0", 8);
542 $buffer[0] = chr(0x0D);
543 $buffer[1] = chr(0x0C);
544 $buffer[2] = chr(0x0B);
545 $buffer[3] = chr(0x0A);
546 $buffer[4] = chr(0x04);
547 $buffer[5] = chr(0x03);
548 $buffer[6] = chr(0x02);
549 $buffer[7] = chr(0x01);
550 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
551 $assert->Equal(0x010203040A0B0C0D, $uut->getLong(0));
552
553 //Test: Signed Long
554 $buffer = str_repeat("\0", 8);
555 $buffer[0] = chr(0x00);
556 $buffer[1] = chr(0x00);
557 $buffer[2] = chr(0x00);
558 $buffer[3] = chr(0x00);
559 $buffer[4] = chr(0x00);
560 $buffer[5] = chr(0x00);
561 $buffer[6] = chr(0x00);
562 $buffer[7] = chr(0x80);
563 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
564 $assert->Equal(-1 << 63, $uut->getLong(0));
565 }
566
567 //Test: ByteBuffer_GetLongChecksOffset
568 $buffer = str_repeat("\0", 8);
569 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
570 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
571 $uut->getLong(8);
572 });
573
574 //Test: ByteBuffer_GetLongChecksLength
575 $buffer = str_repeat("\0", 7);
576 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
577 $assert->Throws(new OutOfRangeException(), function() use ($uut) {
578 $uut->getLong(0);
579 });
580
581 //Test: big endian
582 $buffer = str_repeat("\0", 2);
583 // 0xFF 0x00
584 // Little Endian: 255
585 // Big Endian: 65280
586 $buffer[0] = chr(0xff);
587 $buffer[1] = chr(0x00);
588 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
589 $assert->Equal(65280, $uut->readLittleEndian(0, 2, true));
590
591 $buffer = str_repeat("\0", 4);
592 $buffer[0] = chr(0x0D);
593 $buffer[1] = chr(0x0C);
594 $buffer[2] = chr(0x0B);
595 $buffer[3] = chr(0x0A);
596 $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
597 $assert->Equal(0x0D0C0B0A, $uut->readLittleEndian(0, 4, true));
598
599}
600
601class Assert {
602 public function ok($result, $message = "") {
603 if (!$result){
604 throw new Exception(!empty($message) ? $message : "{$result} is not true.");
605 }
606 }
607
608 public function Equal($result, $expected, $message = "") {
609 if ($result != $expected) {
610 throw new Exception(!empty($message) ? $message : "given the result {$result} is not equals as {$expected}");
611 }
612 }
613
614
615 public function strictEqual($result, $expected, $message = "") {
616 if ($result !== $expected) {
617 throw new Exception(!empty($message) ? $message : "given the result {$result} is not strict equals as {$expected}");
618 }
619 }
620
621 public function Throws($class, Callable $callback) {
622 try {
623 $callback();
624
625 throw new \Exception("passed statement don't throw an exception.");
626 } catch (\Exception $e) {
627 if (get_class($e) != get_class($class)) {
628 throw new Exception("passed statement doesn't throw " . get_class($class) . ". throws " . get_class($e) . ": {$e->getMessage()}");
629 }
630 }
631 }
632}
View as plain text