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