1// Run this using JavaScriptTest.sh 2import assert from 'assert' 3import fs from 'fs' 4import * as flatbuffers from 'flatbuffers' 5 6import { Monster, MonsterT } from './my-game/example/monster' 7import { Test } from './my-game/example/test' 8import { Stat } from './my-game/example/stat' 9import { Vec3 } from './my-game/example/vec3' 10import { Color } from './my-game/example/color'; 11import { Any } from './my-game/example/any'; 12 13function main() { 14 15 // First, let's test reading a FlatBuffer generated by C++ code: 16 // This file was generated from monsterdata_test.json 17 var data = new Uint8Array(fs.readFileSync('monsterdata_test.mon')); 18 19 // Now test it: 20 21 var bb = new flatbuffers.ByteBuffer(data); 22 testBuffer(bb); 23 24 // Second, let's create a FlatBuffer from scratch in JavaScript, and test it also. 25 // We use an initial size of 1 to exercise the reallocation algorithm, 26 // normally a size larger than the typical FlatBuffer you generate would be 27 // better for performance. 28 var fbb = new flatbuffers.Builder(1); 29 createMonster(fbb); 30 serializeAndTest(fbb); 31 testObjApiPack(fbb); 32 33 // clear the builder, repeat tests 34 var clearIterations = 100; 35 var startingCapacity = fbb.bb.capacity(); 36 for (var i = 0; i < clearIterations; i++) { 37 fbb.clear(); 38 createMonster(fbb); 39 serializeAndTest(fbb); 40 testObjApiPack(fbb); 41 } 42 // the capacity of our buffer shouldn't increase with the same size payload 43 assert.strictEqual(fbb.bb.capacity(), startingCapacity); 44 45 test64bit(); 46 testUnicode(); 47 fuzzTest1(); 48 testNullStrings(); 49 testSharedStrings(); 50 51 console.log('FlatBuffers test: completed successfully'); 52} 53 54function createMonster(fbb) { 55 // We set up the same values as monsterdata.json: 56 57 var str = fbb.createString('MyMonster'); 58 59 var inv = Monster.createInventoryVector(fbb, [0, 1, 2, 3, 4]); 60 61 var fred = fbb.createString('Fred'); 62 Monster.startMonster(fbb); 63 Monster.addName(fbb, fred); 64 var mon2 = Monster.endMonster(fbb); 65 66 Monster.startTest4Vector(fbb, 2); 67 Test.createTest(fbb, 10, 20); 68 Test.createTest(fbb, 30, 40); 69 var test4 = fbb.endVector(); 70 71 var testArrayOfString = Monster.createTestarrayofstringVector(fbb, [ 72 fbb.createString('test1'), 73 fbb.createString('test2') 74 ]); 75 76 Monster.startMonster(fbb); 77 Monster.addPos(fbb, Vec3.createVec3(fbb, 1, 2, 3, 3, Color.Green, 5, 6)); 78 Monster.addHp(fbb, 80); 79 Monster.addName(fbb, str); 80 Monster.addInventory(fbb, inv); 81 Monster.addTestType(fbb, Any.Monster); 82 Monster.addTest(fbb, mon2); 83 Monster.addTest4(fbb, test4); 84 Monster.addTestarrayofstring(fbb, testArrayOfString); 85 Monster.addTestbool(fbb, true); 86 var mon = Monster.endMonster(fbb); 87 88 Monster.finishMonsterBuffer(fbb, mon); 89} 90 91function serializeAndTest(fbb) { 92 // Write the result to a file for debugging purposes: 93 // Note that the binaries are not necessarily identical, since the JSON 94 // parser may serialize in a slightly different order than the above 95 // JavaScript code. They are functionally equivalent though. 96 97 fs.writeFileSync('monsterdata_javascript_wire.mon', new Buffer(fbb.asUint8Array())); 98 99 // Tests mutation first. This will verify that we did not trample any other 100 // part of the byte buffer. 101 testMutation(fbb.dataBuffer()); 102 103 testBuffer(fbb.dataBuffer()); 104} 105 106function testMutation(bb) { 107 var monster = Monster.getRootAsMonster(bb); 108 109 monster.mutate_hp(120); 110 assert.strictEqual(monster.hp(), 120); 111 112 monster.mutate_hp(80); 113 assert.strictEqual(monster.hp(), 80); 114 115 var manaRes = monster.mutate_mana(10); 116 assert.strictEqual(manaRes, false); // Field was NOT present, because default value. 117 118 // TODO: There is not the availability to mutate structs or vectors. 119} 120 121function testObjApiPack(fbb) { 122 fbb.clear(); 123 createMonster(fbb); 124 let monster_t = Monster.getRootAsMonster(fbb.dataBuffer()).unpack(); 125 fbb.clear(); 126 Monster.finishMonsterBuffer(fbb, monster_t.pack(fbb)); 127 serializeAndTest(fbb); 128} 129 130function testObjApiUnpack(monster) { 131 assert.strictEqual(monster.hp, 80); 132 assert.strictEqual(monster.mana, 150); // default 133 134 assert.strictEqual(monster.name, 'MyMonster'); 135 136 let pos = monster.pos; 137 assert.strictEqual(pos.x, 1); 138 assert.strictEqual(pos.y, 2); 139 assert.strictEqual(pos.z, 3); 140 assert.strictEqual(pos.test1, 3); 141 assert.strictEqual(pos.test2, Color.Green); 142 let test3 = pos.test3; 143 assert.strictEqual(test3.a, 5); 144 assert.strictEqual(test3.b, 6); 145 146 assert.strictEqual(monster.testType, Any.Monster); 147 let monster2 = monster.test; 148 assert.strictEqual(monster2 != null, true); 149 assert.strictEqual(monster2 instanceof MonsterT, true); 150 assert.strictEqual(monster2.name, 'Fred'); 151 152 assert.strictEqual(monster.inventory.length, 5); 153 let invsum = 0; 154 for (let i = 0; i < monster.inventory.length; i++) { 155 invsum += monster.inventory[i]; 156 } 157 assert.strictEqual(invsum, 10); 158 159 let test_0 = monster.test4[0]; 160 let test_1 = monster.test4[1]; 161 assert.strictEqual(monster.test4.length, 2); 162 assert.strictEqual(test_0.a + test_0.b + test_1.a + test_1.b, 100); 163 164 assert.strictEqual(monster.testarrayofstring.length, 2); 165 assert.strictEqual(monster.testarrayofstring[0], 'test1'); 166 assert.strictEqual(monster.testarrayofstring[1], 'test2'); 167 168 assert.strictEqual(monster.testbool, true); 169} 170 171function testBuffer(bb) { 172 assert.ok(Monster.bufferHasIdentifier(bb)); 173 174 var monster = Monster.getRootAsMonster(bb); 175 176 assert.strictEqual(monster.hp(), 80); 177 assert.strictEqual(monster.mana(), 150); // default 178 179 assert.strictEqual(monster.name(), 'MyMonster'); 180 181 var pos = monster.pos(); 182 assert.strictEqual(pos.x(), 1); 183 assert.strictEqual(pos.y(), 2); 184 assert.strictEqual(pos.z(), 3); 185 assert.strictEqual(pos.test1(), 3); 186 assert.strictEqual(pos.test2(), Color.Green); 187 var t = pos.test3(); 188 assert.strictEqual(t.a(), 5); 189 assert.strictEqual(t.b(), 6); 190 191 assert.strictEqual(monster.testType(), Any.Monster); 192 var monster2 = new Monster(); 193 assert.strictEqual(monster.test(monster2) != null, true); 194 assert.strictEqual(monster2.name(), 'Fred'); 195 196 assert.strictEqual(monster.inventoryLength(), 5); 197 var invsum = 0; 198 for (var i = 0; i < monster.inventoryLength(); i++) { 199 invsum += monster.inventory(i); 200 } 201 assert.strictEqual(invsum, 10); 202 203 var invsum2 = 0; 204 var invArr = monster.inventoryArray(); 205 for (var i = 0; i < invArr.length; i++) { 206 invsum2 += invArr[i]; 207 } 208 assert.strictEqual(invsum2, 10); 209 210 var test_0 = monster.test4(0); 211 var test_1 = monster.test4(1); 212 assert.strictEqual(monster.test4Length(), 2); 213 assert.strictEqual(test_0.a() + test_0.b() + test_1.a() + test_1.b(), 100); 214 215 assert.strictEqual(monster.testarrayofstringLength(), 2); 216 assert.strictEqual(monster.testarrayofstring(0), 'test1'); 217 assert.strictEqual(monster.testarrayofstring(1), 'test2'); 218 219 assert.strictEqual(monster.testbool(), true); 220 221 let monster_t = monster.unpack(); 222 testObjApiUnpack(monster_t); 223 224 let monster2_t = new MonsterT(); 225 monster.unpackTo(monster2_t); 226 testObjApiUnpack(monster2_t); 227} 228 229function test64bit() { 230 var fbb = new flatbuffers.Builder(); 231 var required = fbb.createString('required'); 232 233 Stat.startStat(fbb); 234 var stat2 = Stat.endStat(fbb); 235 236 Monster.startMonster(fbb); 237 Monster.addName(fbb, required); 238 Monster.addTestempty(fbb, stat2); 239 var mon2 = Monster.endMonster(fbb); 240 241 Stat.startStat(fbb); 242 // 2541551405100253985 = 0x87654321(low part) + 0x23456789 * 0x100000000(high part); 243 Stat.addVal(fbb, new flatbuffers.Long(0x87654321, 0x23456789)); // the low part is Uint32 244 var stat = Stat.endStat(fbb); 245 246 Monster.startMonster(fbb); 247 Monster.addName(fbb, required); 248 Monster.addEnemy(fbb, mon2); 249 Monster.addTestempty(fbb, stat); 250 var mon = Monster.endMonster(fbb); 251 252 Monster.finishMonsterBuffer(fbb, mon); 253 var bytes = fbb.asUint8Array(); 254 255 //////////////////////////////////////////////////////////////// 256 257 var bb = new flatbuffers.ByteBuffer(bytes); 258 assert.ok(Monster.bufferHasIdentifier(bb)); 259 var mon = Monster.getRootAsMonster(bb); 260 261 var stat = mon.testempty(); 262 assert.strictEqual(stat != null, true); 263 assert.strictEqual(stat.val() != null, true); 264 assert.strictEqual(stat.val().toFloat64(), 2541551405100253985); 265 266 var mon2 = mon.enemy(); 267 assert.strictEqual(mon2 != null, true); 268 stat = mon2.testempty(); 269 assert.strictEqual(stat != null, true); 270 assert.strictEqual(stat.val() != null, true); 271 assert.strictEqual(stat.val().low, 0); // default value 272 assert.strictEqual(stat.val().high, 0); 273} 274 275function testUnicode() { 276 var correct = fs.readFileSync('unicode_test.mon'); 277 var json = JSON.parse(fs.readFileSync('unicode_test.json', 'utf8')); 278 279 // Test reading 280 function testReadingUnicode(bb) { 281 var monster = Monster.getRootAsMonster(bb); 282 assert.strictEqual(monster.name(), json.name); 283 assert.deepEqual(new Buffer(monster.name(flatbuffers.Encoding.UTF8_BYTES)), new Buffer(json.name)); 284 assert.strictEqual(monster.testarrayoftablesLength(), json.testarrayoftables.length); 285 json.testarrayoftables.forEach(function(table, i) { 286 var value = monster.testarrayoftables(i); 287 assert.strictEqual(value.name(), table.name); 288 assert.deepEqual(new Buffer(value.name(flatbuffers.Encoding.UTF8_BYTES)), new Buffer(table.name)); 289 }); 290 assert.strictEqual(monster.testarrayofstringLength(), json.testarrayofstring.length); 291 json.testarrayofstring.forEach(function(string, i) { 292 assert.strictEqual(monster.testarrayofstring(i), string); 293 assert.deepEqual(new Buffer(monster.testarrayofstring(i, flatbuffers.Encoding.UTF8_BYTES)), new Buffer(string)); 294 }); 295 } 296 testReadingUnicode(new flatbuffers.ByteBuffer(new Uint8Array(correct))); 297 298 // Test writing 299 var fbb = new flatbuffers.Builder(); 300 var name = fbb.createString(json.name); 301 var testarrayoftablesOffsets = json.testarrayoftables.map(function(table) { 302 var name = fbb.createString(new Uint8Array(new Buffer(table.name))); 303 Monster.startMonster(fbb); 304 Monster.addName(fbb, name); 305 return Monster.endMonster(fbb); 306 }); 307 var testarrayoftablesOffset = Monster.createTestarrayoftablesVector(fbb, 308 testarrayoftablesOffsets); 309 var testarrayofstringOffset = Monster.createTestarrayofstringVector(fbb, 310 json.testarrayofstring.map(function(string) { return fbb.createString(string); })); 311 Monster.startMonster(fbb); 312 Monster.addTestarrayofstring(fbb, testarrayofstringOffset); 313 Monster.addTestarrayoftables(fbb, testarrayoftablesOffset); 314 Monster.addName(fbb, name); 315 Monster.finishSizePrefixedMonsterBuffer(fbb, Monster.endMonster(fbb)); 316 var bb = new flatbuffers.ByteBuffer(fbb.asUint8Array()) 317 bb.setPosition(4); 318 testReadingUnicode(bb); 319} 320 321var __imul = Math.imul ? Math.imul : function(a, b) { 322 var ah = a >> 16 & 65535; 323 var bh = b >> 16 & 65535; 324 var al = a & 65535; 325 var bl = b & 65535; 326 return al * bl + (ah * bl + al * bh << 16) | 0; 327}; 328 329// Include simple random number generator to ensure results will be the 330// same cross platform. 331// http://en.wikipedia.org/wiki/Park%E2%80%93Miller_random_number_generator 332var lcg_seed = 48271; 333 334function lcg_rand() { 335 return lcg_seed = (__imul(lcg_seed, 279470273) >>> 0) % 4294967291; 336} 337 338function lcg_reset() { 339 lcg_seed = 48271; 340} 341 342// Converts a Field ID to a virtual table offset. 343function fieldIndexToOffset(field_id) { 344 // Should correspond to what EndTable() below builds up. 345 var fixed_fields = 2; // Vtable size and Object Size. 346 return (field_id + fixed_fields) * 2; 347} 348 349// Low level stress/fuzz test: serialize/deserialize a variety of 350// different kinds of data in different combinations 351function fuzzTest1() { 352 353 // Values we're testing against: chosen to ensure no bits get chopped 354 // off anywhere, and also be different from eachother. 355 var bool_val = true; 356 var char_val = -127; // 0x81 357 var uchar_val = 0xFF; 358 var short_val = -32222; // 0x8222; 359 var ushort_val = 0xFEEE; 360 var int_val = 0x83333333 | 0; 361 var uint_val = 0xFDDDDDDD; 362 var long_val = new flatbuffers.Long(0x44444444, 0x84444444); 363 var ulong_val = new flatbuffers.Long(0xCCCCCCCC, 0xFCCCCCCC); 364 var float_val = new Float32Array([3.14159])[0]; 365 var double_val = 3.14159265359; 366 367 var test_values_max = 11; 368 var fields_per_object = 4; 369 var num_fuzz_objects = 10000; // The higher, the more thorough :) 370 371 var builder = new flatbuffers.Builder(); 372 373 lcg_reset(); // Keep it deterministic. 374 375 var objects = []; 376 377 // Generate num_fuzz_objects random objects each consisting of 378 // fields_per_object fields, each of a random type. 379 for (var i = 0; i < num_fuzz_objects; i++) { 380 builder.startObject(fields_per_object); 381 for (var f = 0; f < fields_per_object; f++) { 382 var choice = lcg_rand() % test_values_max; 383 switch (choice) { 384 case 0: builder.addFieldInt8(f, bool_val, 0); break; 385 case 1: builder.addFieldInt8(f, char_val, 0); break; 386 case 2: builder.addFieldInt8(f, uchar_val, 0); break; 387 case 3: builder.addFieldInt16(f, short_val, 0); break; 388 case 4: builder.addFieldInt16(f, ushort_val, 0); break; 389 case 5: builder.addFieldInt32(f, int_val, 0); break; 390 case 6: builder.addFieldInt32(f, uint_val, 0); break; 391 case 7: builder.addFieldInt64(f, long_val, flatbuffers.Long.ZERO); break; 392 case 8: builder.addFieldInt64(f, ulong_val, flatbuffers.Long.ZERO); break; 393 case 9: builder.addFieldFloat32(f, float_val, 0); break; 394 case 10: builder.addFieldFloat64(f, double_val, 0); break; 395 } 396 } 397 objects.push(builder.endObject()); 398 } 399 builder.prep(8, 0); // Align whole buffer. 400 401 lcg_reset(); // Reset. 402 403 builder.finish(objects[objects.length - 1]); 404 var bytes = new Uint8Array(builder.asUint8Array()); 405 var view = new DataView(bytes.buffer); 406 407 // Test that all objects we generated are readable and return the 408 // expected values. We generate random objects in the same order 409 // so this is deterministic. 410 for (var i = 0; i < num_fuzz_objects; i++) { 411 var offset = bytes.length - objects[i]; 412 for (var f = 0; f < fields_per_object; f++) { 413 var choice = lcg_rand() % test_values_max; 414 var vtable_offset = fieldIndexToOffset(f); 415 var vtable = offset - view.getInt32(offset, true); 416 assert.ok(vtable_offset < view.getInt16(vtable, true)); 417 var field_offset = offset + view.getInt16(vtable + vtable_offset, true); 418 switch (choice) { 419 case 0: assert.strictEqual(!!view.getInt8(field_offset), bool_val); break; 420 case 1: assert.strictEqual(view.getInt8(field_offset), char_val); break; 421 case 2: assert.strictEqual(view.getUint8(field_offset), uchar_val); break; 422 case 3: assert.strictEqual(view.getInt16(field_offset, true), short_val); break; 423 case 4: assert.strictEqual(view.getUint16(field_offset, true), ushort_val); break; 424 case 5: assert.strictEqual(view.getInt32(field_offset, true), int_val); break; 425 case 6: assert.strictEqual(view.getUint32(field_offset, true), uint_val); break; 426 case 7: assert.strictEqual(view.getInt32(field_offset, true), long_val.low); assert.strictEqual(view.getInt32(field_offset + 4, true), long_val.high); break; 427 case 8: assert.strictEqual(view.getInt32(field_offset, true), ulong_val.low); assert.strictEqual(view.getInt32(field_offset + 4, true), ulong_val.high); break; 428 case 9: assert.strictEqual(view.getFloat32(field_offset, true), float_val); break; 429 case 10: assert.strictEqual(view.getFloat64(field_offset, true), double_val); break; 430 } 431 } 432 } 433} 434 435function testSharedStrings() { 436 var shared_string = "Hello world"; 437 var builder = new flatbuffers.Builder(); 438 let mainOffset = builder.createSharedString(shared_string); 439 assert.strictEqual(builder.createSharedString(shared_string), mainOffset); 440} 441 442function testNullStrings() { 443 var builder = new flatbuffers.Builder(); 444 assert.strictEqual(builder.createString(null), 0); 445 assert.strictEqual(builder.createSharedString(null), 0); 446 assert.strictEqual(builder.createString(undefined), 0); 447 assert.strictEqual(builder.createSharedString(undefined), 0); 448} 449 450main(); 451