FM / tests

/mnt/hdd/osrm/build/flatbuffers-build/tests/

/mnt/hdd/osrm/build/flatbuffers-build/tests

Name	Size	Mode	Actions
docker/	-	0755	rm
FlatBuffers.Benchmarks/	-	0755	rm
FlatBuffers.Test/	-	0755	rm
fuzzer/	-	0755	rm
include_test/	-	0755	rm
MyGame/	-	0755	rm
namespace_test/	-	0755	rm
prototest/	-	0755	rm
rust_usage_test/	-	0755	rm
union_vector/	-	0755	rm
arrays_test.bfbs	1064	0644	edit dl rm
arrays_test.fbs	317	0644	edit dl rm
arrays_test.golden	250	0644	edit dl rm
arrays_test.schema.json	1656	0644	edit dl rm
arrays_test_generated.h	13044	0644	edit dl rm
DartTest.sh	1279	0755	edit dl rm
generate_code.bat	3057	0644	edit dl rm
generate_code.sh	2265	0755	edit dl rm
GoTest.sh	2735	0755	edit dl rm
go_test.go	55666	0644	edit dl rm
JavaScriptTest.js	14324	0644	edit dl rm
JavaScriptTest.sh	750	0755	edit dl rm
JavaScriptUnionVectorTest.js	1706	0644	edit dl rm
JavaTest.bat	987	0644	edit dl rm
javatest.bin	512	0644	edit dl rm
JavaTest.java	19159	0644	edit dl rm
JavaTest.sh	1249	0755	edit dl rm
KotlinTest.kt	16450	0644	edit dl rm
KotlinTest.sh	1402	0755	edit dl rm
lobstertest.lobster	4736	0644	edit dl rm
LuaTest.bat	145	0644	edit dl rm
luatest.lua	8235	0644	edit dl rm
LuaTest.sh	747	0755	edit dl rm
monsterdata_extra.json	420	0644	edit dl rm
monsterdata_python_wire.mon	344	0644	edit dl rm
monsterdata_test.golden	1102	0644	edit dl rm
monsterdata_test.json	1225	0644	edit dl rm
monsterdata_test.mon	440	0644	edit dl rm
monster_extra.fbs	484	0644	edit dl rm
monster_extra_generated.h	14039	0644	edit dl rm
monster_test.bfbs	11792	0644	edit dl rm
monster_test.fbs	4255	0644	edit dl rm
monster_test.grpc.fb.cc	9113	0644	edit dl rm
monster_test.grpc.fb.h	25751	0644	edit dl rm
monster_test.schema.json	10148	0644	edit dl rm
monster_test_generated.h	136302	0644	edit dl rm
monster_test_generated.js	87299	0644	edit dl rm
monster_test_generated.lobster	26849	0644	edit dl rm
monster_test_generated.rs	63840	0644	edit dl rm
monster_test_generated.ts	79087	0644	edit dl rm
monster_test_my_game.example2_generated.dart	1520	0644	edit dl rm
monster_test_my_game.example_generated.dart	47861	0644	edit dl rm
monster_test_my_game_generated.dart	1659	0644	edit dl rm
native_type_test.fbs	227	0644	edit dl rm
native_type_test_generated.h	8374	0644	edit dl rm
native_type_test_impl.cpp	342	0644	edit dl rm
native_type_test_impl.h	493	0644	edit dl rm
phpTest.php	24390	0644	edit dl rm
phpUnionVectorTest.php	3906	0644	edit dl rm
phpUnionVectorTest.sh	137	0755	edit dl rm
PythonTest.sh	2785	0755	edit dl rm
py_test.py	66237	0644	edit dl rm
RustTest.bat	874	0644	edit dl rm
RustTest.sh	1298	0755	edit dl rm
test.cpp	124261	0644	edit dl rm
TestAll.sh	985	0644	edit dl rm
test_assert.cpp	2043	0644	edit dl rm
test_assert.h	2580	0644	edit dl rm
test_builder.cpp	5500	0644	edit dl rm
test_builder.h	10395	0644	edit dl rm
TypeScriptTest.sh	1387	0755	edit dl rm
unicode_test.json	503	0644	edit dl rm

Edit: /mnt/hdd/osrm/build/flatbuffers-build/tests/phpTest.php (24390B)

<?php
// manual load for testing. please use PSR style autoloader when you use flatbuffers.
require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "Constants.php"));
require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "ByteBuffer.php"));
require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "FlatbufferBuilder.php"));
require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "Table.php"));
require join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)), "php", "Struct.php"));
foreach (glob(join(DIRECTORY_SEPARATOR, array(dirname(__FILE__), "MyGame", "Example", "*.php"))) as $file) {
    require $file;
}

function main()
{
    /// Begin Test
    $assert = new Assert();

// First, let's test reading a FlatBuffer generated by C++ code:
    // This file was generated from monsterdata_test.json

// Now test it:
    $data = file_get_contents('monsterdata_test.mon');
    $bb = Google\FlatBuffers\ByteBuffer::wrap($data);
    test_buffer($assert, $bb);

// Second, let's create a FlatBuffer from scratch in JavaScript, and test it also.
    // We use an initial size of 1 to exercise the reallocation algorithm,
    // normally a size larger than the typical FlatBuffer you generate would be
    // better for performance.
    $fbb = new Google\FlatBuffers\FlatBufferBuilder(1);

// We set up the same values as monsterdata.json:
    $str = $fbb->createString("MyMonster");
    $name = $fbb->createString('Fred');
    \MyGame\Example\Monster::startMonster($fbb);
    \MyGame\Example\Monster::addName($fbb, $name);
    $enemy = \MyGame\Example\Monster::endMonster($fbb);

$inv = \MyGame\Example\Monster::CreateInventoryVector($fbb, array(0, 1, 2, 3, 4));

$fred = $fbb->createString('Fred');
    \MyGame\Example\Monster::StartMonster($fbb);
    \MyGame\Example\Monster::AddName($fbb, $fred);
    $mon2 = \MyGame\Example\Monster::EndMonster($fbb);

\MyGame\Example\Monster::StartTest4Vector($fbb, 2);
    \MyGame\Example\Test::CreateTest($fbb, 10, 20);
    \MyGame\Example\Test::CreateTest($fbb, 30, 40);
    $test4 = $fbb->endVector();

$testArrayOfString = \MyGame\Example\Monster::CreateTestarrayofstringVector($fbb, array(
        $fbb->createString('test1'),
        $fbb->createString('test2')
    ));

\MyGame\Example\Monster::StartMonster($fbb);
    \MyGame\Example\Monster::AddPos($fbb, \MyGame\Example\Vec3::CreateVec3($fbb,
        1.0, 2.0, 3.0, //float
        3.0, // double
        \MyGame\Example\Color::Green,
        5, //short
        6));
    \MyGame\Example\Monster::AddHp($fbb, 80);
    \MyGame\Example\Monster::AddName($fbb, $str);
    \MyGame\Example\Monster::AddInventory($fbb, $inv);
    \MyGame\Example\Monster::AddTestType($fbb, \MyGame\Example\Any::Monster);
    \MyGame\Example\Monster::AddTest($fbb, $mon2);
    \MyGame\Example\Monster::AddTest4($fbb, $test4);
    \MyGame\Example\Monster::AddTestarrayofstring($fbb, $testArrayOfString);
    \MyGame\Example\Monster::AddEnemy($fbb, $enemy);
    \MyGame\Example\Monster::AddTestbool($fbb, true);
    $mon = \MyGame\Example\Monster::EndMonster($fbb);

\MyGame\Example\Monster::FinishMonsterBuffer($fbb, $mon);

// Test it:
    test_buffer($assert, $fbb->dataBuffer());

testByteBuffer($assert);
    fuzzTest1($assert);
//    testUnicode($assert);

echo 'FlatBuffers php test: completed successfully' . PHP_EOL;
}

try {
    main();
    exit(0);
} catch(Exception $e) {
    printf("Fatal error: Uncaught exception '%s' with message '%s. in %s:%d\n", get_class($e), $e->getMessage(), $e->getFile(), $e->getLine());
    printf("Stack trace:\n");
    echo $e->getTraceAsString() . PHP_EOL;
    printf("  thrown in in %s:%d\n", $e->getFile(), $e->getLine());

die(-1);
}

function test_buffer(Assert $assert, Google\FlatBuffers\ByteBuffer $bb) {

$assert->ok(MyGame\Example\Monster::MonsterBufferHasIdentifier($bb));
    $monster = \MyGame\Example\Monster::GetRootAsMonster($bb);

$assert->strictEqual($monster->GetHp(), 80);
    $assert->strictEqual($monster->GetMana(), 150); // default

$assert->strictEqual($monster->GetName(), 'MyMonster');

$pos = $monster->GetPos();
    $assert->strictEqual($pos->GetX(), 1.0);
    $assert->strictEqual($pos->GetY(), 2.0);
    $assert->strictEqual($pos->GetZ(), 3.0);

$assert->Equal($pos->GetTest1(), 3.0);
    $assert->strictEqual($pos->GetTest2(), \MyGame\Example\Color::Green);

$t = $pos->GetTest3();
    $assert->strictEqual($t->GetA(), 5);
    $assert->strictEqual($t->GetB(), 6);
    $assert->strictEqual($monster->GetTestType(), \MyGame\Example\Any::Monster);

$monster2 = new \MyGame\Example\Monster();
    $assert->strictEqual($monster->GetTest($monster2) != null, true);
    $assert->strictEqual($monster2->GetName(), 'Fred');

$assert->strictEqual($monster->GetInventoryLength(), 5);
    $invsum = 0;
    for ($i = 0; $i < $monster->GetInventoryLength(); $i++) {
        $invsum += $monster->GetInventory($i);
    }
    $assert->strictEqual($invsum, 10);

$assert->strictEqual(bin2hex($monster->GetInventoryBytes()), "0001020304");

$test_0 = $monster->GetTest4(0);
    $test_1 = $monster->GetTest4(1);
    $assert->strictEqual($monster->GetTest4Length(), 2);
    $assert->strictEqual($test_0->GetA() + $test_0->GetB() + $test_1->GetA() + $test_1->GetB(), 100);

$assert->strictEqual($monster->GetTestarrayofstringLength(), 2);
    $assert->strictEqual($monster->GetTestarrayofstring(0), 'test1');
    $assert->strictEqual($monster->GetTestarrayofstring(1), 'test2');

$fred = $monster->getEnemy();
    $assert->Equal('Fred', $fred->getName());

$assert->strictEqual($monster->GetTestbool(), true);
}

//function testUnicode(Assert $assert) {
//    // missing unicode_test.mon, implemented later
//    $correct = file_get_contents('unicode_test.mon');
//    $json = json_decode(file_get_contents('unicode_test.json'));
//
//    // Test reading
//    $bb = flatbuffers\ByteBuffer::Wrap($correct);
//    $monster = \MyGame\Example\Monster::GetRootAsMonster($bb);
//    $assert->strictEqual($monster->GetName(), $json["name"]);
//
//    //$assert->deepEqual(new Buffer(monster.name(flatbuffers.Encoding.UTF8_BYTES)), new Buffer(json.name));
//    //assert.strictEqual(monster.testarrayoftablesLength(), json.testarrayoftables.length);
//    foreach ($json["testarrayoftables"]as $i => $table) {
//        $value = $monster->GetTestArrayOfTables($i);
//        $assert->strictEqual($value->GetName(), $table["name"]);
//        //assert.deepEqual(new Buffer(value.name(flatbuffers.Encoding.UTF8_BYTES)), new Buffer(table.name));
//    }
//    $assert->strictEqual($monster->GetTestarrayofstringLength(), $json["testarrayofstring"]["length"]);
//    foreach ($json["testarrayofstring"] as $i => $string) {
//        $assert->strictEqual($monster->GetTestarrayofstring($i), $string);
//        //assert.deepEqual(new Buffer(monster.testarrayofstring(i, flatbuffers.Encoding.UTF8_BYTES)), new Buffer(string));
//    }
//
//    // Test writing
//    $fbb = new FlatBuffers\FlatBufferBuilder(1);
//    $name = $fbb->CreateString($json["name"]);
//    $testarrayoftablesOffsets = array_map(function($table) use($fbb) {
//        $name = $fbb->CreateString($table["name"]);
//        \MyGame\Example\Monster::StartMonster($fbb);
//        \MyGame\Example\Monster::AddName($fbb, $name);
//        return \MyGame\Example\Monster::EndMonster($fbb);
//    }, $json["testarrayoftables"]);
//    $testarrayoftablesOffset = \MyGame\Example\Monster::CreateTestarrayoftablesVector($fbb,
//            $testarrayoftablesOffsets);
////    $testarrayofstringOffset = \MyGame\Example\Monster::CreateTestarrayofstringVector($fbb,
////            $json["testarrayofstring"].map(function(string) { return fbb.createString(string); }));
//
//    \MyGame\Example\Monster::startMonster($fbb);
//    \MyGame\Example\Monster::addTestarrayofstring($fbb, $testarrayoftablesOffset);
//    \MyGame\Example\Monster::addTestarrayoftables($fbb, $testarrayoftablesOffset);
//    \MyGame\Example\Monster::addName($fbb, $name);
//    \MyGame\Example\Monster::finishMonsterBuffer($fbb, \MyGame\Example\Monster::endMonster($fbb));
//    //;assert.deepEqual(new Buffer(fbb.asUint8Array()), correct);
//}

// Low level stress/fuzz test: serialize/deserialize a variety of
// different kinds of data in different combinations
function fuzzTest1(Assert $assert)
{

// Values we're testing against: chosen to ensure no bits get chopped
    // off anywhere, and also be different from eachother.
    $bool_val = true;
    $char_val = -127; // 0x81
    $uchar_val = 0xFF;
    $short_val = -32222; // 0x8222;
    $ushort_val = 0xFEEE;
    $int_val = 0x7fffffff | 0;
    // for now
    $uint_val = 1;
    $long_val = 2;
    $ulong_val = 3;

//    var uint_val   = 0xFDDDDDDD;
//    var long_val   = new flatbuffers.Long(0x44444444, 0x84444444);
//    var ulong_val  = new flatbuffers.Long(0xCCCCCCCC, 0xFCCCCCCC);

$float_val = 3.14159;
    $double_val = 3.14159265359;

$test_values_max = 11;
    $fields_per_object = 4;
    // current implementation is not good at encoding.
    $num_fuzz_objects = 1000;
    $builder = new Google\FlatBuffers\FlatBufferBuilder(1);

// can't use same implementation due to PHP_INTMAX overflow issue.
    // we use mt_rand function to reproduce fuzzy test.
    mt_srand(48271);
    $objects = array();
    // Generate num_fuzz_objects random objects each consisting of
    // fields_per_object fields, each of a random type.
    for ($i = 0; $i < $num_fuzz_objects; $i++) {
        $builder->startObject($fields_per_object);
        for ($f = 0; $f < $fields_per_object; $f++) {
            $choice = mt_rand() % $test_values_max;
            switch ($choice) {
                case 0:
                    $builder->addBoolX($f, $bool_val, 0);
                    break;
                case 1:
                    $builder->addByteX($f, $char_val, 0);
                    break;
                case 2:
                    $builder->addSbyteX($f, $uchar_val, 0);
                    break;
                case 3:
                    $builder->addShortX($f, $short_val, 0);
                    break;
                case 4:
                    $builder->addUshortX($f, $ushort_val, 0);
                    break;
                case 5:
                    $builder->addIntX($f, $int_val, 0);
                    break;
                case 6:
                    $builder->addUintX($f, $uint_val, 0);
                    break;
                case 7:
                    $builder->addLongX($f, $long_val, 0);
                    break;
                case 8:
                    $builder->addUlongX($f, $ulong_val, 0);
                    break;
                case 9:
                    $builder->addFloatX($f, $float_val, 0);
                    break;
                case 10:
                    $builder->addDoubleX($f, $double_val, 0);
                    break;
            }
        }
        $objects[] = $builder->endObject();
    }
    $builder->prep(8, 0); // Align whole buffer.

mt_srand(48271); // Reset
    $builder->finish($objects[count($objects) - 1]);

$view = Google\FlatBuffers\ByteBuffer::wrap($builder->sizedByteArray());
    for ($i = 0; $i < $num_fuzz_objects; $i++) {
        $offset = $view->capacity() - $objects[$i];
        for ($f = 0; $f < $fields_per_object; $f++) {
            $choice = mt_rand() % $test_values_max;
            $vtable_offset = fieldIndexToOffset($f);
            $vtable = $offset - $view->getInt($offset);
            $assert->ok($vtable_offset < $view->getShort($vtable));
            $field_offset = $offset + $view->getShort($vtable + $vtable_offset);
            switch ($choice) {
                case 0:
                    $assert->strictEqual(!!$view->getBool($field_offset), $bool_val);
                    break;
                case 1:
                    $assert->strictEqual($view->getSbyte($field_offset), $char_val);
                    break;
                case 2:
                    $assert->strictEqual($view->getByte($field_offset), $uchar_val);
                    break;
                case 3:
                    $assert->strictEqual($view->getShort($field_offset), $short_val);
                    break;
                case 4:
                    $assert->strictEqual($view->getUShort($field_offset), $ushort_val);
                    break;
                case 5:
                    $assert->strictEqual($view->getInt($field_offset), $int_val);
                    break;
                case 6:
                    $assert->strictEqual($view->getUint($field_offset), $uint_val);
                    break;
                case 7:
                    if (PHP_INT_SIZE <= 4) break;
                    $assert->strictEqual($view->getLong($field_offset), $long_val);
                    break;
                case 8:
                    if (PHP_INT_SIZE <= 4) break;
                    $assert->strictEqual($view->getUlong($field_offset), $ulong_val);
                    break;
                case 9:
                    $assert->strictEqual(floor($view->getFloat($field_offset)), floor($float_val));
                    break;
                case 10:
                    $assert->strictEqual($view->getDouble($field_offset), $double_val);
                    break;
            }
        }
    }
}

function fieldIndexToOffset($field_id) {
    // Should correspond to what EndTable() below builds up.
    $fixed_fields = 2;  // Vtable size and Object Size.
    return ($field_id + $fixed_fields) * 2;
}

function testByteBuffer(Assert $assert) {

//Test: ByteBuffer_Length_MatchesBufferLength
    $buffer = str_repeat("\0", 100);
    $uut  = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Equal($uut->capacity(), strlen($buffer));

//Test: ByteBuffer_PutBytePopulatesBufferAtZeroOffset
    $buffer = "\0";
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $uut->putByte(0, "\x63"); // 99
    $assert->Equal("\x63", $uut->_buffer[0]); // don't share buffer as php user might confuse reference.

//Test: ByteBuffer_PutByteCannotPutAtOffsetPastLength
    $buffer = "\0";
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->putByte(1, "\x63"); // 99
    });

//Test: ByteBuffer_PutShortPopulatesBufferCorrectly
    $buffer = str_repeat("\0", 2);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $uut->putShort(0, 1);

// Ensure Endiannes was written correctly
    $assert->Equal(chr(0x01), $uut->_buffer[0]);
    $assert->Equal(chr(0x00), $uut->_buffer[1]);

$buffer = str_repeat("\0", 2);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $uut->putShort(0, -32768);

// Ensure Endiannes was written correctly
    $assert->Equal(chr(0x00), $uut->_buffer[0]);
    $assert->Equal(chr(0x80), $uut->_buffer[1]);

//Test: ByteBuffer_PutShortCannotPutAtOffsetPastLength
    $buffer = "\0";
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->putShort(2, "\x63"); // 99
    });

//Test: ByteBuffer_PutShortChecksLength
    $buffer = "\0";
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->putShort(0, "\x63"); // 99
    });

//Test: ByteBuffer_PutShortChecksLengthAndOffset
    $buffer = str_repeat("\0", 2);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->putShort(1, "\x63"); // 99
    });

//Test: ByteBuffer_PutIntPopulatesBufferCorrectly
    $buffer = str_repeat("\0", 4);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $uut->putInt(0, 0x0A0B0C0D);
    $assert->Equal(chr(0x0D), $uut->_buffer[0]);
    $assert->Equal(chr(0x0C), $uut->_buffer[1]);
    $assert->Equal(chr(0x0B), $uut->_buffer[2]);
    $assert->Equal(chr(0x0A), $uut->_buffer[3]);

$buffer = str_repeat("\0", 4);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $uut->putInt(0, -2147483648);
    $assert->Equal(chr(0x00), $uut->_buffer[0]);
    $assert->Equal(chr(0x00), $uut->_buffer[1]);
    $assert->Equal(chr(0x00), $uut->_buffer[2]);
    $assert->Equal(chr(0x80), $uut->_buffer[3]);

//Test: ByteBuffer_PutIntCannotPutAtOffsetPastLength
    $buffer = str_repeat("\0", 4);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->putInt(2, 0x0A0B0C0D);
    });

//Test: ByteBuffer_PutIntChecksLength
    $buffer = str_repeat("\0", 1);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->putInt(0, 0x0A0B0C0D);
    });

//Test: ByteBuffer_PutIntChecksLengthAndOffset
    $buffer = str_repeat("\0", 4);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->putInt(2, 0x0A0B0C0D);
    });

if (PHP_INT_SIZE > 4) {
        //Test: ByteBuffer_PutLongPopulatesBufferCorrectly
        $buffer = str_repeat("\0", 8);
        $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
        $uut->putLong(0, 0x010203040A0B0C0D);
        $assert->Equal(chr(0x0D), $uut->_buffer[0]);
        $assert->Equal(chr(0x0C), $uut->_buffer[1]);
        $assert->Equal(chr(0x0B), $uut->_buffer[2]);
        $assert->Equal(chr(0x0A), $uut->_buffer[3]);
        $assert->Equal(chr(0x04), $uut->_buffer[4]);
        $assert->Equal(chr(0x03), $uut->_buffer[5]);
        $assert->Equal(chr(0x02), $uut->_buffer[6]);
        $assert->Equal(chr(0x01), $uut->_buffer[7]);

//Test: ByteBuffer_PutLongCannotPutAtOffsetPastLength
        $buffer = str_repeat("\0", 8);
        $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
        $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
            $uut->putLong(2, 0x010203040A0B0C0D);
        });

//Test: ByteBuffer_PutLongCannotPutAtOffsetPastLength
        $buffer = str_repeat("\0", 1);
        $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
        $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
            $uut->putLong(0, 0x010203040A0B0C0D);
        });

//Test: ByteBuffer_PutLongChecksLengthAndOffset
        $buffer = str_repeat("\0", 8);
        $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
        $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
            $uut->putLong(2, 0x010203040A0B0C0D);
        });
    }

//Test: ByteBuffer_GetByteReturnsCorrectData
    $buffer = str_repeat("\0", 1);
    $buffer[0] = "\x63";
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Equal("\x63", $uut->get(0));

//Test: ByteBuffer_GetByteChecksOffset
    $buffer = str_repeat("\0", 1);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->get(1);
    });

//Test: ByteBuffer_GetShortReturnsCorrectData
    $buffer = str_repeat("\0", 2);
    $buffer[0] = chr(0x01);
    $buffer[1] = chr(0x00);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Equal(1, $uut->getShort(0));

//Test: ByteBuffer_GetShortReturnsCorrectData (signed value)
    $buffer = str_repeat("\0", 2);
    $buffer[0] = chr(0x00);
    $buffer[1] = chr(0x80);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Equal(-32768, $uut->getShort(0));

//Test: ByteBuffer_GetShortChecksOffset
    $buffer = str_repeat("\0", 2);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->getShort(2);
    });

//Test: ByteBuffer_GetShortChecksLength
    $buffer = str_repeat("\0", 2);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->getShort(1);
    });

//Test: ByteBuffer_GetIntReturnsCorrectData
    $buffer = str_repeat("\0", 4);
    $buffer[0] = chr(0x0D);
    $buffer[1] = chr(0x0C);
    $buffer[2] = chr(0x0B);
    $buffer[3] = chr(0x0A);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Equal(0x0A0B0C0D, $uut->getInt(0));

$buffer = str_repeat("\0", 4);
    $buffer[0] = chr(0x00);
    $buffer[1] = chr(0x00);
    $buffer[2] = chr(0x00);
    $buffer[3] = chr(0x80);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Equal(-2147483648, $uut->getInt(0));

//Test: ByteBuffer_GetIntChecksOffset
    $buffer = str_repeat("\0", 4);

$uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->getInt(4);
    });

//Test: ByteBuffer_GetIntChecksLength
    $buffer = str_repeat("\0", 2);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->getInt(0);
    });

if (PHP_INT_SIZE > 4) {
        //Test: ByteBuffer_GetLongReturnsCorrectData
        $buffer = str_repeat("\0", 8);
        $buffer[0] = chr(0x0D);
        $buffer[1] = chr(0x0C);
        $buffer[2] = chr(0x0B);
        $buffer[3] = chr(0x0A);
        $buffer[4] = chr(0x04);
        $buffer[5] = chr(0x03);
        $buffer[6] = chr(0x02);
        $buffer[7] = chr(0x01);
        $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
        $assert->Equal(0x010203040A0B0C0D, $uut->getLong(0));

//Test: Signed Long
        $buffer = str_repeat("\0", 8);
        $buffer[0] = chr(0x00);
        $buffer[1] = chr(0x00);
        $buffer[2] = chr(0x00);
        $buffer[3] = chr(0x00);
        $buffer[4] = chr(0x00);
        $buffer[5] = chr(0x00);
        $buffer[6] = chr(0x00);
        $buffer[7] = chr(0x80);
        $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
        $assert->Equal(-1 << 63, $uut->getLong(0));
    }

//Test: ByteBuffer_GetLongChecksOffset
    $buffer = str_repeat("\0", 8);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->getLong(8);
    });

//Test: ByteBuffer_GetLongChecksLength
    $buffer = str_repeat("\0", 7);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Throws(new OutOfRangeException(), function()  use ($uut) {
        $uut->getLong(0);
    });

//Test: big endian
    $buffer = str_repeat("\0", 2);
    // 0xFF 0x00
    // Little Endian: 255
    // Big Endian: 65280
    $buffer[0] = chr(0xff);
    $buffer[1] = chr(0x00);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Equal(65280, $uut->readLittleEndian(0, 2, true));

$buffer = str_repeat("\0", 4);
    $buffer[0] = chr(0x0D);
    $buffer[1] = chr(0x0C);
    $buffer[2] = chr(0x0B);
    $buffer[3] = chr(0x0A);
    $uut = Google\FlatBuffers\ByteBuffer::wrap($buffer);
    $assert->Equal(0x0D0C0B0A, $uut->readLittleEndian(0, 4, true));

}

class Assert {
    public function ok($result, $message = "") {
        if (!$result){
            throw new Exception(!empty($message) ? $message : "{$result} is not true.");
        }
    }

public function Equal($result, $expected, $message = "") {
        if ($result != $expected) {
            throw new Exception(!empty($message) ? $message : "given the result {$result} is not equals as {$expected}");
        }
    }

public function strictEqual($result, $expected, $message = "") {
        if ($result !== $expected) {
            throw new Exception(!empty($message) ? $message : "given the result {$result} is not strict equals as {$expected}");
        }
    }

public function Throws($class, Callable $callback) {
        try {
            $callback();

throw new \Exception("passed statement don't throw an exception.");
        } catch (\Exception $e) {
            if (get_class($e) != get_class($class)) {
                throw new Exception("passed statement doesn't throw " . get_class($class) . ". throwws " . get_class($e));
            }
        }
    }
}

cmd: