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